diff --git a/public/roadmap-content/ai-engineer.json b/public/roadmap-content/ai-engineer.json index 27c09d679..c6fd05c6f 100644 --- a/public/roadmap-content/ai-engineer.json +++ b/public/roadmap-content/ai-engineer.json @@ -1113,8 +1113,19 @@ }, "dLEg4IA3F5jgc44Bst9if": { "title": "Models on Hugging Face", - "description": "", - "links": [] + "description": "Embedding models are used to convert raw data like text, code, or images into high-dimensional vectors that capture semantic meaning. These vector representations allow AI systems to compare, cluster, and retrieve information based on similarity rather than exact matches. Hugging Face provides a wide range of pretrained embedding models such as `all-MiniLM-L6-v2`, `gte-base`, `Qwen3-Embedding-8B` and `bge-base` which are commonly used for tasks like semantic search, recommendation systems, duplicate detection, and retrieval-augmented generation (RAG). These models can be accessed through libraries like transformers or sentence-transformers, making it easy to generate high-quality embeddings for both general-purpose and task-specific applications.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Hugging Face Embedding Models", + "url": "https://huggingface.co/models?pipeline_tag=feature-extraction", + "type": "article" + }, + { + "title": "Hugging Face - Text embeddings & semantic search", + "url": "https://www.youtube.com/watch?v=OATCgQtNX2o", + "type": "video" + } + ] }, "tt9u3oFlsjEMfPyojuqpc": { "title": "Vector Databases", diff --git a/public/roadmap-content/angular.json b/public/roadmap-content/angular.json index 8b84d742f..965ce885b 100644 --- a/public/roadmap-content/angular.json +++ b/public/roadmap-content/angular.json @@ -137,6 +137,11 @@ "title": "Anatomy of a Component", "url": "https://angular.dev/guide/components", "type": "article" + }, + { + "title": "Anatomy of a Component - Interactive Tutorial", + "url": "https://angular.dev/tutorials/learn-angular/1-components-in-angular", + "type": "article" } ] }, diff --git a/public/roadmap-content/blockchain.json b/public/roadmap-content/blockchain.json index b844a498e..f7f497f7e 100644 --- a/public/roadmap-content/blockchain.json +++ b/public/roadmap-content/blockchain.json @@ -2833,11 +2833,6 @@ "url": "https://chain.link/education-hub/blockchain", "type": "article" }, - { - "title": "What Is The Blockchain And Why Does It Matter?", - "url": "https://www.forbes.com/sites/theyec/2020/05/18/what-is-the-blockchain-and-why-does-it-matter/", - "type": "article" - }, { "title": "Web3/Crypto: Why Bother?", "url": "https://continuations.com/post/671863718643105792/web3crypto-why-bother", diff --git a/public/roadmap-content/cyber-security.json b/public/roadmap-content/cyber-security.json index 632c940a3..148e28d2b 100644 --- a/public/roadmap-content/cyber-security.json +++ b/public/roadmap-content/cyber-security.json @@ -4,7 +4,7 @@ "description": "Fundamental IT skills form the backbone of cybersecurity proficiency and encompass a broad range of technical knowledge. These skills include understanding computer hardware and software, networking concepts, and operating systems (particularly Windows and Linux). Proficiency in at least one programming language, such as Python or JavaScript, is increasingly important for automation and scripting tasks. Database management, including SQL, is crucial for handling and securing data. Knowledge of cloud computing platforms like AWS or Azure is becoming essential as organizations migrate to cloud environments. Familiarity with basic cybersecurity concepts such as encryption, access control, and common attack vectors provides a foundation for more advanced security work. Additionally, troubleshooting skills, the ability to interpret logs, and a basic understanding of web technologies are vital. These fundamental IT skills enable cybersecurity professionals to effectively protect systems, identify vulnerabilities, and respond to incidents in increasingly complex technological landscapes.\n\nLearn more from the following resources:", "links": [ { - "title": "7 In-Demand IT Skills to Boost Your Resume in 2025", + "title": "8 In-Demand IT Skills to Boost Your Resume in 2025", "url": "https://www.coursera.org/articles/key-it-skills-for-your-career", "type": "article" }, @@ -342,6 +342,11 @@ "url": "https://www.comptia.org/certifications/linux", "type": "article" }, + { + "title": "CompTIA Linux+ Certification Training Labs", + "url": "https://github.com/labex-labs/comptia-linux-plus-training-labs", + "type": "article" + }, { "title": "Linux+ Exam Prep", "url": "https://www.youtube.com/watch?v=niPWk7tgD2Q&list=PL78ppT-_wOmuwT9idLvuoKOn6UYurFKCp", diff --git a/public/roadmap-content/design-system.json b/public/roadmap-content/design-system.json index 6b6c1b22f..dbbf5a059 100644 --- a/public/roadmap-content/design-system.json +++ b/public/roadmap-content/design-system.json @@ -246,7 +246,12 @@ "links": [ { "title": "Design Systems: Pilots & Scorecards", - "url": "https://superfriendly.com/design-systems/articles/design-systems-pilots-scorecards/", + "url": "https://danmall.com/posts/design-systems-pilots-scorecards/", + "type": "article" + }, + { + "title": "How to run a design system pilot", + "url": "https://university.obvious.in/product-design/design-system/how-to-run-a-design-system-pilot", "type": "article" } ] diff --git a/public/roadmap-content/devops.json b/public/roadmap-content/devops.json index a47e36a89..ce844b193 100644 --- a/public/roadmap-content/devops.json +++ b/public/roadmap-content/devops.json @@ -570,8 +570,8 @@ "type": "article" }, { - "title": "Vim Adventures", - "url": "https://vim-adventures.com/", + "title": "Practical Vim 2nd Edition", + "url": "https://dokumen.pub/practical-vim-2nd-edition-2nd-edition-9781680501278.html", "type": "article" }, { diff --git a/public/roadmap-content/docker.json b/public/roadmap-content/docker.json index b570db9cd..827cabc79 100644 --- a/public/roadmap-content/docker.json +++ b/public/roadmap-content/docker.json @@ -378,22 +378,6 @@ } ] }, - "HlTxLqKNFMhghtKF6AcWu": { - "title": "Interactive Test Environments", - "description": "Docker allows you to create isolated, disposable environments that can be deleted once you're done with testing. This makes it much easier to work with third party software, test different dependencies or versions, and quickly experiment without the risk of damaging your local setup.\n\nVisit the following resources to learn more:", - "links": [ - { - "title": "Launch a Dev Environment", - "url": "https://docs.docker.com/desktop/dev-environments/create-dev-env/", - "type": "article" - }, - { - "title": "Test Environments - Medium", - "url": "https://manishsaini74.medium.com/containerized-testing-orchestrating-test-environments-with-docker-5201bfadfdf2", - "type": "article" - } - ] - }, "YzpB7rgSR4ueQRLa0bRWa": { "title": "Command Line Utilities", "description": "Docker images can include command line utilities or standalone applications that we can run inside containers.\n\nVisit the following resources to learn more:", diff --git a/public/roadmap-content/engineering-manager.json b/public/roadmap-content/engineering-manager.json index 26fcea214..229fcdf70 100644 --- a/public/roadmap-content/engineering-manager.json +++ b/public/roadmap-content/engineering-manager.json @@ -568,11 +568,6 @@ "description": "The role of an Engineering Manager extends to external collaboration as well. Here, they often serve the role of liaising with external teams, vendors, or partners, aligning goals and ensuring smooth communication flow. The key responsibilities include managing relationships, understanding the partner ecosystem, and negotiating win-win situations.\n\nEngineering Managers face challenges like cultural differences, communication hurdles, or time zone disparities. They address these by building reliability through regular updates, clear agendas, and understanding each other's work culture.\n\nTo succeed, Engineering Managers need good interpersonal skills, a keen eye for future opportunities, and the ability to adapt quickly. An understanding of business and sales, alongside engineering knowledge, can be advantageous too. This role needs balance - drive details when necessary and step back and delegate when appropriate.", "links": [] }, - "TQY4hjo56rDdlbzjs_-nl": { - "title": "Competitive Analysis", - "description": "An Engineering Manager uses competitive analysis to understand market trends and competitor strategies. This aids in decision-making and strategic planning. Their key responsibilities include identifying key competitors, analyzing their products, sales, and marketing strategies.\n\nChallenges may arise from having incomplete or inaccurate data. In these cases, Engineering Managers have to rely on their judgement and experience. Their analysis should be unbiased and as accurate as possible to influence the right design and development strategies.\n\nSuccessful competitive analysis requires strong analytical skills, keen attention to detail, and the ability to understand complex market dynamics. Managers must stay updated on market trend, technological advancements and be able to distinguish their company's unique selling proposition. This will allow them to plan steps to maintain competitiveness in the market.", - "links": [] - }, "QUxpEK8smXRBs2gMdDInB": { "title": "Legacy System Retirement", "description": "Every Engineering Manager knows the value and hurdles of legacy system retirement. They must plan and manage this complex task with a keen understanding of the system's purpose, its interdependencies, and potential risks of its retirement. Key responsibilities include assessing the impact on users, mitigating downtime, and ensuring business continuity.\n\nChallenges often arise from lack of documentation or knowledge about the legacy system. To overcome this, they could organize knowledge-sharing sessions with long-standing team members, assessing external help, or gradual transition methods.\n\nThe successful retirement of a legacy system requires a comprehensive approach, good interpersonal skills for team collaboration, and strong decision-making skills. An Engineering Manager has to balance the system’s business value against the cost and risk of maintaining it.", diff --git a/public/roadmap-content/full-stack.json b/public/roadmap-content/full-stack.json index 75461d33f..5bf5208f8 100644 --- a/public/roadmap-content/full-stack.json +++ b/public/roadmap-content/full-stack.json @@ -448,7 +448,7 @@ }, "SHTSvMDqI7X1_ZT7-m--n": { "title": "Linux Basics", - "description": "Knowledge of UNIX is a must for almost all kind of development as most of the codes that you write is most likely going to be finally deployed on a UNIX/Linux machine. Linux has been the backbone of the free and open source software movement, providing a simple and elegant operating system for almost all your needs.\n\nVisit the following resources to learn more:", + "description": "Knowledge of UNIX is a must for almost all kind of development as most of the code that you write is most likely going to be finally deployed on a UNIX/Linux machine. Linux has been the backbone of the free and open source software movement, providing a simple and elegant operating system for almost all your needs.\n\nVisit the following resources to learn more:", "links": [ { "title": "Coursera - Unix Courses", diff --git a/public/roadmap-content/golang.json b/public/roadmap-content/golang.json index cef8eead0..a675dbd14 100644 --- a/public/roadmap-content/golang.json +++ b/public/roadmap-content/golang.json @@ -1,862 +1,3439 @@ { "WwLLyHL5psm0GOI9bmOne": { "title": "Introduction to Go", - "description": "Statically typed, compiled programming language developed at Google. Designed for simplicity, concurrency, and performance. Features garbage collection, strong typing, efficient compilation, built-in concurrency with goroutines and channels. Excellent for backend services, CLI tools, and distributed systems.", - "links": [] + "description": "Statically typed, compiled programming language developed at Google. Designed for simplicity, concurrency, and performance. Features garbage collection, strong typing, efficient compilation, built-in concurrency with goroutines and channels. Excellent for backend services, CLI tools, and distributed systems.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go", + "url": "https://go.dev/", + "type": "article" + }, + { + "title": "Go Documentation", + "url": "https://go.dev/doc/", + "type": "article" + }, + { + "title": "Get Started with Go", + "url": "https://go.dev/doc/tutorial/getting-started", + "type": "article" + }, + { + "title": "Getting Started with Go and the Web", + "url": "https://dev.to/markmunyaka/getting-started-with-go-and-the-web-hello-world-nal", + "type": "article" + } + ] }, "4PrkkoZ5fY-oow0O-bVhu": { "title": "Why use Go", - "description": "Go offers exceptional performance with single binary deployment, built-in concurrency, fast compilation, and comprehensive standard library. Simple language that's easy to learn and maintain. Excels at web services, microservices, CLI tools, and system software.", - "links": [] + "description": "Go offers exceptional performance with single binary deployment, built-in concurrency, fast compilation, and comprehensive standard library. Simple language that's easy to learn and maintain. Excels at web services, microservices, CLI tools, and system software.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Why Go - The Go Programming Language", + "url": "https://go.dev/solutions/", + "type": "article" + }, + { + "title": "Why Go: The benefits of Golang", + "url": "https://medium.com/@julienetienne/why-go-the-benefits-of-golang-6c39ea6cff7e", + "type": "article" + }, + { + "title": "What Is Golang Used For? 7 Examples of Go Applications", + "url": "https://trio.dev/what-is-golang-used-for/", + "type": "article" + } + ] }, "2rlmLn_yQQV-7DpX1qT98": { "title": "History of Go", - "description": "Created at Google in 2007 by Griesemer, Pike, and Thompson. Announced publicly in 2009, version 1.0 in 2012. Key milestones include modules (Go 1.11) and generics (Go 1.18). Designed for large-scale software development combining efficiency and simplicity.", - "links": [] + "description": "Created at Google in 2007 by Griesemer, Pike, and Thompson. Announced publicly in 2009, version 1.0 in 2012. Key milestones include modules (Go 1.11) and generics (Go 1.18). Designed for large-scale software development combining efficiency and simplicity.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Documentation", + "url": "https://go.dev/doc/", + "type": "article" + }, + { + "title": "Go — How It All Began. A look back at the beginning of Go", + "url": "https://medium.com/geekculture/learn-go-part-1-the-beginning-723746f2e8b0", + "type": "article" + }, + { + "title": "Understanding Golang: A Comprehensive Guide", + "url": "https://www.learn-golang.org/en/Hello%2C_World%21", + "type": "article" + } + ] }, "J5mU0v491qrm-mr1W3Msd": { "title": "Setting up the Environment", - "description": "Install Go from official website, configure PATH, and set up workspace. Configure editor with Go support (VS Code, GoLand, Vim/Emacs). Use modules for dependency management. Verify installation with `go version` and test with simple program.", - "links": [] + "description": "Install Go from official website, configure PATH, and set up workspace. Configure editor with Go support (VS Code, GoLand, Vim/Emacs). Use modules for dependency management. Verify installation with `go version` and test with simple program.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Golang", + "url": "https://go.dev/", + "type": "article" + }, + { + "title": "Setting up the Environment", + "url": "https://go.dev/doc/install", + "type": "article" + }, + { + "title": "How to Set Up a Go Development Environment?", + "url": "https://medium.com/codex/how-to-set-up-a-go-development-environment-67b4b002182e", + "type": "article" + } + ] }, "PHHviBSqhYDSNuHBFbw3l": { "title": "Hello World in Go", - "description": "Traditional first program demonstrating basic structure: `package main`, importing `fmt`, and `main()` function using `fmt.Println()`. Teaches Go syntax, compilation, execution, and verifies development environment setup. Entry point for learning Go.", - "links": [] + "description": "Traditional first program demonstrating basic structure: `package main`, importing `fmt`, and `main()` function using `fmt.Println()`. Teaches Go syntax, compilation, execution, and verifies development environment setup. Entry point for learning Go.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Documentation", + "url": "https://go.dev/doc/", + "type": "article" + }, + { + "title": "Get Started with Go", + "url": "https://go.dev/doc/tutorial/getting-started", + "type": "article" + }, + { + "title": "Getting Started with Go and the Web", + "url": "https://dev.to/markmunyaka/getting-started-with-go-and-the-web-hello-world-nal", + "type": "article" + }, + { + "title": "Understanding Golang: A Comprehensive Guide", + "url": "https://www.learn-golang.org/en/Hello%2C_World%21", + "type": "article" + } + ] }, "_3_tFOpQisx6DSP4Yc2E2": { "title": "`go` command", - "description": "Primary tool for managing Go source code with unified interface for compiling, testing, formatting, and managing dependencies. Includes subcommands like `build`, `run`, `test`, `fmt`, `mod`. Handles the entire development workflow automatically.", - "links": [] + "description": "Primary tool for managing Go source code with unified interface for compiling, testing, formatting, and managing dependencies. Includes subcommands like `build`, `run`, `test`, `fmt`, `mod`. Handles the entire development workflow automatically.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Command Documentation", + "url": "https://go.dev/doc/cmd", + "type": "article" + }, + { + "title": "Go Package", + "url": "https://pkg.go.dev/cmd/go", + "type": "article" + }, + { + "title": "Go Test", + "url": "https://go.dev/doc/tutorial/add-a-test", + "type": "article" + }, + { + "title": "Compile and Install Application", + "url": "https://go.dev/doc/tutorial/compile-install", + "type": "article" + } + ] }, "BZKSsTgm28WV4nA74NYHO": { "title": "Variables & Constants", - "description": "Variables store changeable values declared with `var` or `:=` (short declaration). Constants store unchangeable values declared with `const`. Variables can be explicitly typed or use type inference. Constants must be compile-time determinable. Both support block declarations and package/function scope.", - "links": [] + "description": "Variables store changeable values declared with `var` or `:=` (short declaration). Constants store unchangeable values declared with `const`. Variables can be explicitly typed or use type inference. Constants must be compile-time determinable. Both support block declarations and package/function scope.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Shorthand Assignment", + "url": "https://go.dev/tour/basics/10", + "type": "article" + }, + { + "title": "Var Assignment", + "url": "https://go.dev/tour/basics/8", + "type": "article" + }, + { + "title": "How To Use Variables and Constants in Go", + "url": "https://www.digitalocean.com/community/tutorials/how-to-use-variables-and-constants-in-go", + "type": "article" + } + ] }, "pJUkMcrUvcxuR_w89-eEq": { "title": "var vs :=", - "description": "", - "links": [] + "description": "Go provides two main ways to declare variables: using `var` and using the short declaration operator `:=`.\n\nThe `var` keyword is used for explicit variable declarations. You can use it to define a variable with or without assigning a value. If no value is provided, Go assigns a default _zero value_ based on the variable type. `var` can be used both inside and outside functions.\n\nThe `:=` syntax is a shorthand for declaring and initializing a variable. It infers the type from the value and can only be used **inside functions**. This is a quick and convenient way to create variables without explicitly mentioning their types.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Tour: Short variable declarations", + "url": "https://go.dev/tour/basics/10", + "type": "article" + }, + { + "title": "Go Specification: Short Variable Declarations", + "url": "https://go.dev/ref/spec#Short_variable_declarations", + "type": "article" + } + ] }, "QWixUXjC8YG-i1gsKVY1v": { "title": "Zero Values", - "description": "Default values for uninitialized variables: `0` for numbers, `false` for booleans, `\"\"` for strings, `nil` for pointers/slices/maps. Ensures predictable initial state and reduces initialization errors. Fundamental for reliable Go code.", - "links": [] + "description": "Default values for uninitialized variables: `0` for numbers, `false` for booleans, `\"\"` for strings, `nil` for pointers/slices/maps. Ensures predictable initial state and reduces initialization errors. Fundamental for reliable Go code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Zero Values", + "url": "https://go.dev/tour/basics/12", + "type": "article" + }, + { + "title": "Golang Zero Values (0 and Beyond)", + "url": "https://golangprojectstructure.com/default-zero-values-in-go-code/", + "type": "article" + }, + { + "title": "Zero Values in Golang", + "url": "https://www.scaler.com/topics/golang/golang-zero-values/", + "type": "article" + } + ] }, "-M-qrXwVt7HfJv0CSRNGS": { "title": "const and iota", - "description": "Constants declared with `const` represent unchanging compile-time values. `iota` creates successive integer constants starting from zero, resetting per `const` block. Useful for enumerations, bit flags, and constant sequences without manual values.", - "links": [] + "description": "Constants declared with `const` represent unchanging compile-time values. `iota` creates successive integer constants starting from zero, resetting per `const` block. Useful for enumerations, bit flags, and constant sequences without manual values.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Iota", + "url": "https://go.dev/wiki/Iota", + "type": "article" + }, + { + "title": "Constants", + "url": "https://webreference.com/go/basics/constants/", + "type": "article" + } + ] }, "xUKsD2eTP9-RszHvKYp9Y": { "title": "Scope and Shadowing", - "description": "Scope determines variable accessibility from universe to block level. Shadowing occurs when inner scope variables hide outer ones with same names. Go has package, function, and block scopes. Understanding prevents bugs from accidentally creating new variables.", - "links": [] + "description": "Scope determines variable accessibility from universe to block level. Shadowing occurs when inner scope variables hide outer ones with same names. Go has package, function, and block scopes. Understanding prevents bugs from accidentally creating new variables.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go #010 - Variable Scope and Shadowing", + "url": "https://dev.to/imzihad21/go-010-variable-scope-and-shadowing-footguns-explained-3djp", + "type": "article" + }, + { + "title": "Variable Shadowing in Go: Best Practices", + "url": "https://medium.com/@shahpershahin/variable-shadowing-in-go-best-practices-to-avoid-confusions-and-bugs-61e03022b54d", + "type": "article" + } + ] }, "0FJxELyk7_IiVHvZFFVm2": { "title": "Data Types", - "description": "Rich set of built-in types: integers (int8-64), unsigned integers (uint8-64), floats (float32/64), complex numbers, booleans, strings, runes. Statically typed - types determined at compile time for early error detection and performance. Crucial for efficient, reliable programs.", - "links": [] + "description": "Rich set of built-in types: integers (int8-64), unsigned integers (uint8-64), floats (float32/64), complex numbers, booleans, strings, runes. Statically typed - types determined at compile time for early error detection and performance. Crucial for efficient, reliable programs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Basics", + "url": "https://go.dev/tour/basics/11", + "type": "article" + }, + { + "title": "Basic Data Types in Go", + "url": "https://golangbot.com/types/", + "type": "article" + }, + { + "title": "Understanding Data Types in Go", + "url": "https://www.digitalocean.com/community/tutorials/understanding-data-types-in-go", + "type": "article" + } + ] }, "PRTou83_rD0u7p2elGG4s": { "title": "Boolean", - "description": "The `bool` type represents `true` or `false` values with default zero value of `false`. Essential for conditional logic, control flow, and binary states. Results from comparison (`==`, `!=`) and logical operations (`&&`, `||`, `!`).", - "links": [] + "description": "The `bool` type represents `true` or `false` values with default zero value of `false`. Essential for conditional logic, control flow, and binary states. Results from comparison (`==`, `!=`) and logical operations (`&&`, `||`, `!`).\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Booleans in Golang", + "url": "https://golangdocs.com/booleans-in-golang", + "type": "article" + }, + { + "title": "Understanding Boolean Logic in Go", + "url": "https://www.digitalocean.com/community/tutorials/understanding-boolean-logic-in-go", + "type": "article" + } + ] }, "EAqL8Up3J63AWCZnqQph0": { "title": "Integers (Signed, Unsigned)", - "description": "Signed integers (int8, int16, int32, int64) handle positive/negative numbers. Unsigned (uint8, uint16, uint32, uint64) handle only non-negative but larger positive range. `int`/`uint` are platform-dependent. Choose based on range and memory needs.", - "links": [] + "description": "Signed integers (int8, int16, int32, int64) handle positive/negative numbers. Unsigned (uint8, uint16, uint32, uint64) handle only non-negative but larger positive range. `int`/`uint` are platform-dependent. Choose based on range and memory needs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Integers", + "url": "https://golangdocs.com/integers-in-golang", + "type": "article" + }, + { + "title": "Understanding Integer Types in Go", + "url": "https://medium.com/@LukePetersonAU/understanding-integer-types-in-go-a55453f5ae00", + "type": "article" + } + ] }, "EzaH378F3kOdQbczhVjhA": { "title": "Floating Points", - "description": "Two types: `float32` (single precision) and `float64` (double precision, default). Represent real numbers using IEEE 754 standard. Can introduce precision errors, not suitable for exact financial calculations. Essential for scientific computing and graphics.", - "links": [] + "description": "Two types: `float32` (single precision) and `float64` (double precision, default). Represent real numbers using IEEE 754 standard. Can introduce precision errors, not suitable for exact financial calculations. Essential for scientific computing and graphics.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Floating Points", + "url": "https://golangdocs.com/floating-point-numbers-in-golang", + "type": "article" + }, + { + "title": "How to Perform Float Point Calculations", + "url": "https://labex.io/tutorials/go-how-to-perform-float-point-calculations-419745", + "type": "article" + } + ] }, "Mn-M7kxOKEublJGitgjNA": { "title": "Complex Numbers", - "description": "Built-in support with `complex64` and `complex128` types. Create using `complex()` function or literals like `3+4i`. Provides `real()`, `imag()`, `abs()` functions. Useful for mathematical computations, signal processing, and scientific applications.", - "links": [] + "description": "Built-in support with `complex64` and `complex128` types. Create using `complex()` function or literals like `3+4i`. Provides `real()`, `imag()`, `abs()` functions. Useful for mathematical computations, signal processing, and scientific applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Complex Numbers", + "url": "https://go.dev/ref/spec", + "type": "article" + }, + { + "title": "Complex Numbers in Golang", + "url": "https://golangdocs.com/complex-numbers-in-golang", + "type": "article" + }, + { + "title": "Complex Data Types in Golang", + "url": "https://dev.to/diwakarkashyap/complex-data-types-in-golang-go-328l", + "type": "article" + } + ] }, "IAXI7OAAAG4fU6JvVNSZI": { "title": "Runes", - "description": "Represent Unicode code points as `int32` type. Enable proper handling of international characters and emojis. Use single quotes like `'A'` or `'中'`. Essential for internationalized applications and correctly processing global text content beyond ASCII.", - "links": [] + "description": "Represent Unicode code points as `int32` type. Enable proper handling of international characters and emojis. Use single quotes like `'A'` or `'中'`. Essential for internationalized applications and correctly processing global text content beyond ASCII.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Characters in Go", + "url": "https://go.dev/blog/strings", + "type": "article" + }, + { + "title": "Understanding Runes in Go", + "url": "https://dev.to/jeseekuya/understanding-runes-in-go-4ie5", + "type": "article" + }, + { + "title": "Demystifying Runes: A Complete Guide to Using Runes in Go", + "url": "https://thelinuxcode.com/golang-rune/", + "type": "article" + } + ] }, "nzPe6XVqhtOZFbea6f2Hg": { "title": "Raw String Literals", - "description": "Enclosed in backticks (\\`) and interpret characters literally without escape sequences. Preserve formatting including newlines. Ideal for regex, file paths, SQL queries, JSON templates, and multi-line text where escaping would be extensive.", - "links": [] + "description": "Enclosed in backticks (\\`) and interpret characters literally without escape sequences. Preserve formatting including newlines. Ideal for regex, file paths, SQL queries, JSON templates, and multi-line text where escaping would be extensive.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Carriage Returns", + "url": "https://go.dev/ref/spec", + "type": "article" + }, + { + "title": "Golang Quick Reference: Strings. Introduction ", + "url": "https://medium.com/@golangda/golang-quick-reference-strings-0d68bb036c29", + "type": "article" + } + ] }, "7h08RUNC_uAMI6vnGdcZ1": { "title": "Interpreted String Literals", - "description": "Enclosed in double quotes (`\"`) and process escape sequences like `\\n`, `\\t`, `\\\"`. Support Unicode characters and formatting. Most common string type, ideal for text needing control characters but requiring escaping of special characters.", - "links": [] + "description": "Enclosed in double quotes (`\"`) and process escape sequences like `\\n`, `\\t`, `\\\"`. Support Unicode characters and formatting. Most common string type, ideal for text needing control characters but requiring escaping of special characters.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "How to handle string literal syntax", + "url": "https://www.digitalocean.com/community/tutorials/an-introduction-to-working-with-strings-in-go", + "type": "article" + }, + { + "title": "Lexical elements: Interpreted string literals", + "url": "https://boldlygo.tech/archive/2023-01-30-lexical-elements-interpreted-string-literals/", + "type": "article" + } + ] }, "2IFxz3sFqDvUvzWNVwlWC": { "title": "Type Conversion", - "description": "Convert values between different types using `Type(value)` syntax. Go requires explicit conversion even between related types like `int` and `int64`. Essential for working with different data types and ensuring type compatibility in programs.", - "links": [] + "description": "Convert values between different types using `Type(value)` syntax. Go requires explicit conversion even between related types like `int` and `int64`. Essential for working with different data types and ensuring type compatibility in programs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Type Conversion", + "url": "https://go.dev/tour/basics/13", + "type": "article" + }, + { + "title": "A Comprehensive Guide to Type Casting and Conversions in Go", + "url": "https://dev.to/zakariachahboun/a-comprehensive-guide-to-type-casting-and-conversions-in-go-26di", + "type": "article" + }, + { + "title": "Safe Go Type Conversions: Comprehensive Guide", + "url": "https://medium.com/lyonas/go-type-casting-starter-guide-a9c1811670c5", + "type": "article" + } + ] }, "ywiNCAAvpSVXTwWwguxSZ": { "title": "Commands & Docs", - "description": "Go provides built-in documentation tools including `go doc` for terminal documentation and `godoc` for web interface. Documentation uses special comments. `go help` provides command information. Essential for exploring standard library and writing well-documented code.", - "links": [] + "description": "Go provides built-in documentation tools including `go doc` for terminal documentation and `godoc` for web interface. Documentation uses special comments. `go help` provides command information. Essential for exploring standard library and writing well-documented code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Doc", + "url": "https://go.dev/godoc", + "type": "article" + }, + { + "title": "A Guide to Effective Go Documentation", + "url": "https://nirdoshgautam.medium.com/a-guide-to-effective-go-documentation-952f346d073f", + "type": "article" + } + ] }, "Eu8JV-_W-P_bCx_PglIW0": { "title": "Arrays", - "description": "Fixed-size sequences of same-type elements. Size is part of the type, so different sizes are different types. Declared with specific length, initialized to zero values. Value types (copied when assigned/passed). Slices are more commonly used due to flexibility. Foundation for understanding Go's type system.", - "links": [] + "description": "Fixed-size sequences of same-type elements. Size is part of the type, so different sizes are different types. Declared with specific length, initialized to zero values. Value types (copied when assigned/passed). Slices are more commonly used due to flexibility. Foundation for understanding Go's type system.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Arrays", + "url": "https://go.dev/tour/moretypes/6", + "type": "article" + }, + { + "title": "A Complete Guide to Arrays in Golang", + "url": "https://www.kelche.co/blog/go/golang-arrays/", + "type": "article" + } + ] }, "3aoMFQXIh3Qdo04isHwe_": { "title": "Slices", - "description": "Dynamic arrays built on top of arrays. Reference types with length and capacity. Created with `make()` or slice literals. Support append, copy operations. More flexible than arrays - most commonly used sequence type in Go.", - "links": [] + "description": "Dynamic arrays built on top of arrays. Reference types with length and capacity. Created with `make()` or slice literals. Support append, copy operations. More flexible than arrays - most commonly used sequence type in Go.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "make", + "url": "https://go.dev/tour/moretypes/13", + "type": "article" + }, + { + "title": "The new() vs make() Functions in Go", + "url": "https://nitish08.medium.com/loops-in-golang-d44fb39b08e", + "type": "article" + }, + { + "title": "Slice Arrays Correctly", + "url": "https://labex.io/tutorials/go-how-to-slice-arrays-correctly-418936", + "type": "article" + } + ] }, "qUykEUH1-9Dzotc_ltV3g": { "title": "Capacity and Growth", - "description": "Slice capacity determines when reallocation occurs during append operations. Go typically doubles capacity for smaller slices. Pre-allocate with `make([]T, length, capacity)` to optimize memory usage and minimize allocations in performance-critical code.", - "links": [] + "description": "Slice capacity determines when reallocation occurs during append operations. Go typically doubles capacity for smaller slices. Pre-allocate with `make([]T, length, capacity)` to optimize memory usage and minimize allocations in performance-critical code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Understanding Go's Slice Data Structure and Its Growth Pattern", + "url": "https://medium.com/@arjun.devb25/understanding-gos-slice-data-structure-and-its-growth-pattern-48fe6dd914b4", + "type": "article" + }, + { + "title": "How to Increase Slice Capacity in Go", + "url": "https://thekoreanguy.medium.com/how-does-the-capacity-change-when-you-append-to-a-slice-in-go-46289dad4730", + "type": "article" + }, + { + "title": "How to Manage Slice Length and Capacity", + "url": "https://labex.io/tutorials/go-how-to-manage-slice-length-and-capacity-418932", + "type": "article" + } + ] }, "PWrfmYnOJRlwgdFat91bC": { "title": "make()", - "description": "Creates and initializes slices, maps, and channels. Unlike `new()`, returns usable values. Examples: `make([]int, 5, 10)` for slices, `make(map[string]int)` for maps, `make(chan int)` for channels. Essential for initializing reference types.", - "links": [] + "description": "Creates and initializes slices, maps, and channels. Unlike `new()`, returns usable values. Examples: `make([]int, 5, 10)` for slices, `make(map[string]int)` for maps, `make(chan int)` for channels. Essential for initializing reference types.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "make", + "url": "https://go.dev/tour/moretypes/13", + "type": "article" + }, + { + "title": "The new() vs make() Functions in Go", + "url": "https://nitish08.medium.com/loops-in-golang-d44fb39b08e", + "type": "article" + }, + { + "title": "Understanding the make Function in Golang", + "url": "https://www.zetcode.com/golang/builtins-make/", + "type": "article" + } + ] }, "j0zmfpaufr5TAZa_Bh8Vu": { "title": "Slice to Array Conversion", - "description": "Convert slice to array using `[N]T(slice)` (Go 1.17+). Copies data from slice to fixed-size array. Panics if slice has fewer than N elements. Useful when array semantics or specific size guarantees are needed.", - "links": [] + "description": "Convert slice to array using `[N]T(slice)` (Go 1.17+). Copies data from slice to fixed-size array. Panics if slice has fewer than N elements. Useful when array semantics or specific size guarantees are needed.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Slice Arrays Correctly", + "url": "https://labex.io/tutorials/go-how-to-slice-arrays-correctly-418936", + "type": "article" + }, + { + "title": "Go - Create Slice From Array - 3 Examples", + "url": "https://www.tutorialkart.com/golang-tutorial/golang-create-slice-from-array/", + "type": "article" + } + ] }, "s1E4PQVVSlBeyNn7xBikW": { "title": "Array to Slice Conversion", - "description": "Convert arrays to slices using expressions like `array[:]` or `array[start:end]`. Creates slice header pointing to array memory - no data copying. Modifications through slice affect original array. Efficient way to use arrays with slice-based APIs.", - "links": [] + "description": "Convert arrays to slices using expressions like `array[:]` or `array[start:end]`. Creates slice header pointing to array memory - no data copying. Modifications through slice affect original array. Efficient way to use arrays with slice-based APIs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Slice Arrays Correctly", + "url": "https://labex.io/tutorials/go-how-to-slice-arrays-correctly-418936", + "type": "article" + }, + { + "title": "Go - Create Slice From Array - 3 Examples", + "url": "https://www.tutorialkart.com/golang-tutorial/golang-create-slice-from-array/", + "type": "article" + } + ] }, "ZxZpReGdPq8ziSlYmf2nj": { "title": "Strings", - "description": "Immutable sequences of bytes representing UTF-8 encoded text. String operations create new strings rather than modifying existing ones. Iterate by bytes (indexing) or runes (for range). Convert between strings and byte slices. Understanding strings helps with text manipulation and performance.", - "links": [] + "description": "Immutable sequences of bytes representing UTF-8 encoded text. String operations create new strings rather than modifying existing ones. Iterate by bytes (indexing) or runes (for range). Convert between strings and byte slices. Understanding strings helps with text manipulation and performance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "String", + "url": "https://go.dev/blog/strings", + "type": "article" + }, + { + "title": "Go Speculation", + "url": "https://go.dev/ref/spec", + "type": "article" + }, + { + "title": "Golang Quick Reference: Strings. Introduction ", + "url": "https://medium.com/@golangda/golang-quick-reference-strings-0d68bb036c29", + "type": "article" + } + ] }, "XupDuVRsM5VjdaNs7JaT5": { "title": "Maps", - "description": "Built-in associative data type mapping keys to values. Reference types created with `make(map[KeyType]ValueType)` or map literals. Keys must be comparable types. Support insertion, deletion, lookup operations. Check existence with comma ok idiom: `value, ok := map[key]`.", - "links": [] + "description": "Built-in associative data type mapping keys to values. Reference types created with `make(map[KeyType]ValueType)` or map literals. Keys must be comparable types. Support insertion, deletion, lookup operations. Check existence with comma ok idiom: `value, ok := map[key]`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Maps", + "url": "https://go.dev/blog/maps", + "type": "article" + }, + { + "title": "Mastering Go Maps: Best Practices & Pro Tips", + "url": "https://blog.stackademic.com/golang-use-maps-like-pro-the-proper-way-to-use-maps-in-golang-7a20c805540c", + "type": "article" + }, + { + "title": "Understanding HashMaps in DSA", + "url": "https://medium.com/@nikhil.cse16/understanding-hashmaps-in-dsa-5450c6ec2e75", + "type": "article" + } + ] }, "dMdOz2kUc8If3LcLZEfYf": { "title": "Comma-Ok Idiom", - "description": "Pattern for safely testing map key existence or type assertion success using `value, ok := map[key]` or `value, ok := interface.(Type)`. Returns both value and boolean status, preventing panics and distinguishing zero values from missing keys.", - "links": [] + "description": "Pattern for safely testing map key existence or type assertion success using `value, ok := map[key]` or `value, ok := interface.(Type)`. Returns both value and boolean status, preventing panics and distinguishing zero values from missing keys.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Comma Ok", + "url": "https://go.dev/tour/basics/10", + "type": "article" + }, + { + "title": "The Comma Ok Idiom ", + "url": "https://dev.to/saurabh975/comma-ok-in-go-l4f", + "type": "article" + }, + { + "title": "How the Comma Ok Idiom and Package System Work in Go", + "url": "https://www.freecodecamp.org/news/how-the-comma-ok-idiom-and-package-system-work-in-go/", + "type": "article" + }, + { + "title": "Statement Idioms in Go", + "url": "https://medium.com/@nateogbonna/statement-idioms-in-go-writing-clean-idiomatic-go-code-6fe92e6e8ab4", + "type": "article" + } + ] }, "wRwt9JHZPmq8uapxMjn0a": { "title": "Structs", - "description": "Custom data types grouping related fields under single name. Similar to classes but methods defined separately. Create complex data models, organize information, define application data structure. Access fields with dot notation, pass to functions. Fundamental for object-oriented designs.", - "links": [] + "description": "Custom data types grouping related fields under single name. Similar to classes but methods defined separately. Create complex data models, organize information, define application data structure. Access fields with dot notation, pass to functions. Fundamental for object-oriented designs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Structs", + "url": "https://go.dev/wiki/Well-known-struct-tags", + "type": "article" + }, + { + "title": "Working with JSON and Struct Tags", + "url": "https://medium.com/@sanyamdubey28/working-with-json-and-struct-tags-in-go-0e6a7c4fc6b0", + "type": "article" + }, + { + "title": "Understanding Struct Tags and JSON Encoding in Go", + "url": "https://towardsdev.com/understanding-struct-tags-and-json-encoding-in-go-9e51d551c0ce", + "type": "article" + } + ] }, "SW2uMlhfC-dnQakShs2km": { "title": "Struct Tags & JSON", - "description": "Struct tags provide metadata about fields using backticks with key-value pairs. JSON tags control field names, omit empty fields, or skip fields. Example: `json:\"name,omitempty\"`. Essential for APIs and data serialization formats.", - "links": [] + "description": "Struct tags provide metadata about fields using backticks with key-value pairs. JSON tags control field names, omit empty fields, or skip fields. Example: `json:\"name,omitempty\"`. Essential for APIs and data serialization formats.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Structs", + "url": "https://go.dev/wiki/Well-known-struct-tags", + "type": "article" + }, + { + "title": "Working with JSON and Struct Tags", + "url": "https://medium.com/@sanyamdubey28/working-with-json-and-struct-tags-in-go-0e6a7c4fc6b0", + "type": "article" + } + ] }, "XLj16RmCe4-nKHW52Ebhf": { "title": "Embedding Structs", - "description": "Struct embedding includes one struct inside another without field names, making embedded fields directly accessible. Provides composition-based design following Go's philosophy of composition over inheritance. Enables flexible, reusable components.", - "links": [] + "description": "Struct embedding includes one struct inside another without field names, making embedded fields directly accessible. Provides composition-based design following Go's philosophy of composition over inheritance. Enables flexible, reusable components.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Struct Embedding", + "url": "https://gobyexample.com/struct-embedding", + "type": "article" + }, + { + "title": "Interfaces and Embedding in Golang (Go)", + "url": "https://dev.to/diwakarkashyap/interfaces-and-embedding-in-golang-go-2em4", + "type": "article" + } + ] }, "C7wzT161ytHsCpO2zfmXo": { "title": "Conditionals", - "description": "Control program flow based on conditions. `if` for basic logic, `if-else` for binary decisions, `switch` for multiple conditions. `if` supports optional initialization, no parentheses needed but braces required. `switch` supports expressions, type switches, fallthrough. Fundamental for business logic.", - "links": [] + "description": "Control program flow based on conditions. `if` for basic logic, `if-else` for binary decisions, `switch` for multiple conditions. `if` supports optional initialization, no parentheses needed but braces required. `switch` supports expressions, type switches, fallthrough. Fundamental for business logic.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Flow Control", + "url": "https://go.dev/tour/flowcontrol/6", + "type": "article" + }, + { + "title": "How To Write Conditional Statements in Go", + "url": "https://www.digitalocean.com/community/tutorials/how-to-write-conditional-statements-in-go", + "type": "article" + }, + { + "title": "How to handle conditional logic in Go", + "url": "https://labex.io/tutorials/go-how-to-handle-conditional-logic-in-go-418319", + "type": "article" + } + ] }, "dC-1LotbW29C4zZJv6ak6": { "title": "if", - "description": "Basic conditional statement for executing code based on boolean conditions. Supports optional initialization statement before condition check. No parentheses required around condition but braces mandatory. Can be chained with else if for multiple conditions. Foundation of control flow.", - "links": [] + "description": "Basic conditional statement for executing code based on boolean conditions. Supports optional initialization statement before condition check. No parentheses required around condition but braces mandatory. Can be chained with else if for multiple conditions. Foundation of control flow.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "if else", + "url": "https://go.dev/tour/flowcontrol/7", + "type": "article" + }, + { + "title": "If-else: Gobyexample", + "url": "https://gobyexample.com/if-else", + "type": "article" + }, + { + "title": "Understanding the If Statement in Golang", + "url": "https://www.zetcode.com/golang/if-else-keywords/", + "type": "article" + } + ] }, "2XaDvTJ5pyChgt1GFZF8W": { "title": "if-else", - "description": "Basic conditional statements for binary decision making. `if` tests condition, `else` handles alternative path. Can include optional initialization statement. No parentheses needed around condition but braces required. Foundation of program control flow.", - "links": [] + "description": "Basic conditional statements for binary decision making. `if` tests condition, `else` handles alternative path. Can include optional initialization statement. No parentheses needed around condition but braces required. Foundation of program control flow.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "if else", + "url": "https://go.dev/tour/flowcontrol/7", + "type": "article" + }, + { + "title": "If-else: Gobyexample", + "url": "https://gobyexample.com/if-else", + "type": "article" + } + ] }, "ZmPhiTrB8EK0LDdaJOhc8": { "title": "switch", - "description": "Clean way to compare variable against multiple values and execute corresponding code blocks. No break statements needed (no fall-through by default). Works with any comparable type, supports multiple values per case, expression/type switches. More readable than if-else chains.", - "links": [] + "description": "Clean way to compare variable against multiple values and execute corresponding code blocks. No break statements needed (no fall-through by default). Works with any comparable type, supports multiple values per case, expression/type switches. More readable than if-else chains.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Switch", + "url": "https://go.dev/wiki/Switch", + "type": "article" + }, + { + "title": "Go by Example: Switch", + "url": "https://gobyexample.com/switch", + "type": "article" + }, + { + "title": "Learn Switch Statement in Go (Golang) with Examples", + "url": "https://golangbot.com/switch/", + "type": "article" + } + ] }, "orpxzKHFcf1BDQSefHl6O": { "title": "Loops", - "description": "Go has only one looping construct: the flexible `for` loop. Basic form has initialization, condition, post statement. Supports `for range` for arrays, slices, maps, strings, channels. Can create infinite loops or while-style loops. Control with `break` and `continue`.", - "links": [] + "description": "Go has only one looping construct: the flexible `for` loop. Basic form has initialization, condition, post statement. Supports `for range` for arrays, slices, maps, strings, channels. Can create infinite loops or while-style loops. Control with `break` and `continue`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Loops", + "url": "https://go.dev/tour/flowcontrol/1", + "type": "article" + }, + { + "title": "Loops in GoLang. GoLang Loops, For Loop, While loop", + "url": "https://nitish08.medium.com/loops-in-golang-d44fb39b08e", + "type": "article" + }, + { + "title": "Everything You Need to Know About for Loops in Go", + "url": "https://www.bytesizego.com/blog/golang-for-loop", + "type": "article" + } + ] }, "ijS-b400c9BldRO6PlrC1": { "title": "for loop", - "description": "Go's only looping construct, incredibly flexible for all iteration needs. Classic form: initialization, condition, post statements. Omit components for different behaviors (infinite, while-like). Use with `break`, `continue`, labels for nested loops. `for range` for convenient collection iteration.", - "links": [] + "description": "Go's only looping construct, incredibly flexible for all iteration needs. Classic form: initialization, condition, post statements. Omit components for different behaviors (infinite, while-like). Use with `break`, `continue`, labels for nested loops. `for range` for convenient collection iteration.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "for", + "url": "https://go.dev/tour/flowcontrol/1", + "type": "article" + }, + { + "title": "Learn for loops in Go with Examples", + "url": "https://golangbot.com/loops/", + "type": "article" + } + ] }, "j0w6e8Pksh30PKDvXj3yk": { "title": "for range", - "description": "Special form of for loop for iterating over arrays, slices, maps, strings, and channels. Returns index/key and value. For strings, returns rune index and rune value. For channels, returns only values. Use blank identifier `_` to ignore unwanted return values.", - "links": [] + "description": "Special form of for loop for iterating over arrays, slices, maps, strings, and channels. Returns index/key and value. For strings, returns rune index and rune value. For channels, returns only values. Use blank identifier `_` to ignore unwanted return values.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Range", + "url": "https://go.dev/wiki/Range", + "type": "article" + }, + { + "title": "for", + "url": "https://go.dev/tour/flowcontrol/1", + "type": "article" + }, + { + "title": "Select & For Range Channel in Go", + "url": "https://blog.devtrovert.com/p/select-and-for-range-channel-i-bet", + "type": "article" + } + ] }, "Q6ic-AGG_gnXEOdmqom89": { "title": "Iterating Maps", - "description": "Use `for range` to iterate over maps, returns key and value pairs. Iteration order is random for security reasons. Use blank identifier `_` to ignore key or value. Cannot modify map during iteration unless creating new map. Safe to delete during iteration.", - "links": [] + "description": "Use `for range` to iterate over maps, returns key and value pairs. Iteration order is random for security reasons. Use blank identifier `_` to ignore key or value. Cannot modify map during iteration unless creating new map. Safe to delete during iteration.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Building High-Performance File Processing Pipelines in Go", + "url": "https://dev.to/aaravjoshi/building-high-performance-file-processing-pipelines-in-go-a-complete-guide-3opm", + "type": "article" + }, + { + "title": "Mastering File I/O in Go: A Complete Guide", + "url": "https://thelinuxcode.com/golang-os-open/", + "type": "article" + }, + { + "title": "Golang Fundamentals: File Handling and I/O", + "url": "https://medium.com/@nagarjun_nagesh/golang-fundamentals-file-handling-and-i-o-502d50b96795", + "type": "article" + } + ] }, "PC-azlCZ6wDCn1_nRyhUn": { "title": "Iterating Strings", - "description": "Iterate over strings with `for range` to get runes (Unicode code points) not bytes. Returns index and rune value. Direct indexing `str[i]` gives bytes. Use `[]rune(str)` to convert to rune slice for random access. Important for Unicode handling.", - "links": [] + "description": "Iterate over strings with `for range` to get runes (Unicode code points) not bytes. Returns index and rune value. Direct indexing `str[i]` gives bytes. Use `[]rune(str)` to convert to rune slice for random access. Important for Unicode handling.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Iterators in GoLang", + "url": "https://blog.alexoglou.com/posts/iterators-golang/", + "type": "article" + }, + { + "title": "How to iterate string in Go", + "url": "https://labex.io/tutorials/go-how-to-iterate-string-in-go-446115", + "type": "article" + }, + { + "title": "Mastering Golang String Manipulation: Functions and Examples", + "url": "https://learngolanguage.com/mastering-golang-string-manipulation-essential-functions-and-techniques-for-2024/", + "type": "article" + } + ] }, "IWdAJ1BXqJv8EMYvFWRaH": { "title": "break", - "description": "Immediately exits innermost loop or switch statement. In nested loops, only exits immediate loop unless used with labels to break outer loops. Essential for early termination when conditions are met. Helps write efficient loops that don't continue unnecessarily.", - "links": [] + "description": "Immediately exits innermost loop or switch statement. In nested loops, only exits immediate loop unless used with labels to break outer loops. Essential for early termination when conditions are met. Helps write efficient loops that don't continue unnecessarily.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Using Break and Continue Statements When Working with Loop", + "url": "https://www.digitalocean.com/community/tutorials/using-break-and-continue-statements-when-working-with-loops-in-go", + "type": "article" + }, + { + "title": "Demystifying the Break and Continue Statements in Golang", + "url": "https://medium.com/@kiruu1238/break-continue-bc35e9f3802d", + "type": "article" + } + ] }, "BRKryB5HawXyXeBWM4QqU": { "title": "continue", - "description": "Skips rest of current iteration and jumps to next loop iteration. Only affects innermost loop unless used with labels. Useful for filtering elements, handling special cases early, avoiding nested conditionals. Makes loops cleaner and more efficient.", - "links": [] + "description": "Skips rest of current iteration and jumps to next loop iteration. Only affects innermost loop unless used with labels. Useful for filtering elements, handling special cases early, avoiding nested conditionals. Makes loops cleaner and more efficient.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Using Break and Continue Statements When Working with Loop", + "url": "https://www.digitalocean.com/community/tutorials/using-break-and-continue-statements-when-working-with-loops-in-go", + "type": "article" + }, + { + "title": "Demystifying the Break and Continue Statements in Golang", + "url": "https://medium.com/@kiruu1238/break-continue-bc35e9f3802d", + "type": "article" + } + ] }, "O29VoTfPiU8GZ_c16ZJIp": { "title": "goto (discouraged)", - "description": "Go includes `goto` statement but discourages its use. Can only jump to labels within same function. Creates unstructured code flow making programs hard to read, debug, and maintain. Use structured control flow (loops, functions, conditionals) instead. Rarely needed in modern Go programming.", - "links": [] + "description": "Go includes `goto` statement but discourages its use. Can only jump to labels within same function. Creates unstructured code flow making programs hard to read, debug, and maintain. Use structured control flow (loops, functions, conditionals) instead. Rarely needed in modern Go programming.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Goto Statement Usage", + "url": "https://labex.io/tutorials/go-goto-statement-usage-149074", + "type": "article" + }, + { + "title": "GoLang — Jumping in the code using goto", + "url": "https://medium.com/@rajasoni1995/golang-jumping-in-the-code-using-goto-a36116831396", + "type": "article" + }, + { + "title": "Goto Hell With Labels in Golang", + "url": "https://programmingpercy.tech/blog/goto-hell-with-labels-in-golang/", + "type": "article" + } + ] }, "axhcEfCEoFkLey4AbA84A": { "title": "Functions", - "description": "First-class citizens in Go. Declared with `func` keyword, support parameters and return values. Can be assigned to variables, passed as arguments, returned from other functions. Support multiple return values, named returns, and variadic parameters. Building blocks of modular code.", - "links": [] + "description": "First-class citizens in Go. Declared with `func` keyword, support parameters and return values. Can be assigned to variables, passed as arguments, returned from other functions. Support multiple return values, named returns, and variadic parameters. Building blocks of modular code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Functions", + "url": "https://go.dev/tour/basics/4", + "type": "article" + }, + { + "title": "Functions in Golang: Complete Guide with Examples", + "url": "https://medium.com/backend-forge/functions-in-golang-complete-guide-with-examples-2025-e07db0f98fd3", + "type": "article" + }, + { + "title": "Learn Go Functions", + "url": "https://www.learn-golang.org/en/Functions", + "type": "article" + } + ] }, "MBafBhpEV_7qgDNPOIBBs": { "title": "Functions Basics", - "description": "Reusable code blocks declared with `func` keyword. Support parameters, return values, multiple returns. First-class citizens - can be assigned to variables, passed as arguments. Fundamental building blocks for organizing code logic.", - "links": [] + "description": "Reusable code blocks declared with `func` keyword. Support parameters, return values, multiple returns. First-class citizens - can be assigned to variables, passed as arguments. Fundamental building blocks for organizing code logic.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Functions", + "url": "https://go.dev/tour/basics/4", + "type": "article" + }, + { + "title": "Functions in Golang: Complete Guide with Examples", + "url": "https://medium.com/backend-forge/functions-in-golang-complete-guide-with-examples-2025-e07db0f98fd3", + "type": "article" + } + ] }, "MUJfa0jIL_S_b2ndNpVVw": { "title": "Variadic Functions", - "description": "Functions accepting variable number of arguments of same type. Syntax: `func name(args ...Type)`. Arguments treated as slice inside function. Call with multiple args or slice with `...` operator. Common in functions like `fmt.Printf()` and `append()`.", - "links": [] + "description": "Functions accepting variable number of arguments of same type. Syntax: `func name(args ...Type)`. Arguments treated as slice inside function. Call with multiple args or slice with `...` operator. Common in functions like `fmt.Printf()` and `append()`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Unpacking Go Variadic Functions: Clever Ways to Use Them", + "url": "https://dev.to/shrsv/unpacking-go-variadic-functions-clever-ways-to-use-them-4p25", + "type": "article" + }, + { + "title": "How To Use Variadic Functions in Go -", + "url": "https://www.digitalocean.com/community/tutorials/how-to-use-variadic-functions-in-go", + "type": "article" + } + ] }, "ai2s1bwiTcPzrXQTxFDwV": { "title": "Multiple Return Values", - "description": "Go functions can return multiple values, commonly used for returning result and error. Syntax: `func name() (Type1, Type2)`. Caller receives all returned values or uses blank identifier `_` to ignore unwanted values. Idiomatic for error handling pattern.", - "links": [] + "description": "Go functions can return multiple values, commonly used for returning result and error. Syntax: `func name() (Type1, Type2)`. Caller receives all returned values or uses blank identifier `_` to ignore unwanted values. Idiomatic for error handling pattern.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Multiple Return Values in Go", + "url": "https://engineerpalsu.medium.com/multiple-return-values-in-go-7aa5511d3050", + "type": "article" + }, + { + "title": "How to manage Go function multiple returns", + "url": "https://labex.io/tutorials/go-how-to-manage-go-function-multiple-returns-419825", + "type": "article" + } + ] }, "cEQ9NQX7ZkKLwz_hg9L_7": { "title": "Anonymous Functions", - "description": "Functions declared without names, also called function literals or lambdas. Can be assigned to variables, passed as arguments, or executed immediately. Useful for short operations, callbacks, goroutines, and closures. Access enclosing scope variables. Common in event handlers and functional patterns.", - "links": [] + "description": "Functions declared without names, also called function literals or lambdas. Can be assigned to variables, passed as arguments, or executed immediately. Useful for short operations, callbacks, goroutines, and closures. Access enclosing scope variables. Common in event handlers and functional patterns.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Anonymous Functions", + "url": "https://golangdocs.com/anonymous-functions-in-golang", + "type": "article" + }, + { + "title": "Understanding Anonymous Functions in Go: A Practical Guide", + "url": "https://dev.to/abstractmusa/understanding-anonymous-functions-in-go-a-practical-guide-57hd", + "type": "article" + } + ] }, "ZSiNvYDTW2RYyPttls5iz": { "title": "Closures", - "description": "Functions capturing variables from surrounding scope, accessible even after outer function returns. \"Close over\" external variables for specialized functions, callbacks, state maintenance. Useful for event handling, iterators, functional programming. Important for flexible, reusable code.", - "links": [] + "description": "Functions capturing variables from surrounding scope, accessible even after outer function returns. \"Close over\" external variables for specialized functions, callbacks, state maintenance. Useful for event handling, iterators, functional programming. Important for flexible, reusable code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Closures in Golang", + "url": "https://go.dev/tour/moretypes/25", + "type": "article" + }, + { + "title": "Understanding Closures in Go", + "url": "https://code101.medium.com/understanding-closures-in-go-encapsulating-state-and-behaviour-558ac3617671", + "type": "article" + } + ] }, "HIvwT8Dcr6B2NjOjy9hFv": { "title": "Named Return Values", - "description": "Function return parameters can be named and treated as variables within function. Initialized to zero values. `return` statement without arguments returns current values of named parameters. Improves readability and enables easier refactoring but use judiciously.", - "links": [] + "description": "Function return parameters can be named and treated as variables within function. Initialized to zero values. `return` statement without arguments returns current values of named parameters. Improves readability and enables easier refactoring but use judiciously.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Named Return Values", + "url": "https://yourbasic.org/golang/named-return-values-parameters/", + "type": "article" + }, + { + "title": "Named Return Values in Go", + "url": "https://golang.ntxm.org/docs/functions-in-go/named-return-values/", + "type": "article" + }, + { + "title": "Named Parameters in Go: Use Cases and Cautions", + "url": "https://medium.com/@adamszpilewicz/named-parameters-in-go-use-cases-and-cautions-e0e462cafdaa", + "type": "article" + } + ] }, "z8-8nt-3GA7uN-cvOI-Qn": { "title": "Call by Value", - "description": "Go creates copies of values when passing to functions, not references to originals. Applies to all types including structs and arrays. Provides safety but can be expensive for large data. Use pointers, slices, maps for references. Critical for performance optimization.", - "links": [] + "description": "Go creates copies of values when passing to functions, not references to originals. Applies to all types including structs and arrays. Provides safety but can be expensive for large data. Use pointers, slices, maps for references. Critical for performance optimization.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Build Package", + "url": "https://pkg.go.dev/go/build", + "type": "article" + }, + { + "title": "Compile and Install Application", + "url": "https://go.dev/doc/tutorial/compile-install", + "type": "article" + }, + { + "title": "Advanced Go Build Techniques", + "url": "https://dev.to/jacktt/go-build-in-advance-4o8n", + "type": "article" + }, + { + "title": "Customizing Go Binaries with Build Tags", + "url": "https://www.digitalocean.com/community/tutorials/customizing-go-binaries-with-build-tags", + "type": "article" + }, + { + "title": "How To Build and Install Go Programs", + "url": "https://www.digitalocean.com/community/tutorials/how-to-build-and-install-go-programs", + "type": "article" + } + ] }, "naBjKGrTBzlpapXzLHfvG": { "title": "Pointers", - "description": "Variables storing memory addresses of other variables. Enable efficient memory usage and allow functions to modify values. Declared with `*Type`, address obtained with `&`. No pointer arithmetic for safety. Essential for performance and building data structures.", - "links": [] + "description": "Variables storing memory addresses of other variables. Enable efficient memory usage and allow functions to modify values. Declared with `*Type`, address obtained with `&`. No pointer arithmetic for safety. Essential for performance and building data structures.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Pointers", + "url": "https://go.dev/tour/moretypes/1", + "type": "article" + }, + { + "title": "Understanding Value and Pointer Receivers in Golang", + "url": "https://medium.com/the-bug-shots/understanding-value-and-pointer-receivers-in-golang-82dd73a3eef9", + "type": "article" + }, + { + "title": "Complete Guide to Pointers in Go: From Basics to Best Practices", + "url": "https://www.willworth.dev/Go-Pointers", + "type": "article" + } + ] }, "P0fUxEbb3bVYg35VWyg8R": { "title": "Pointers Basics", - "description": "Variables storing memory addresses of other variables. Declared with `*Type`, dereferenced with `*ptr`, address obtained with `&var`. Enable efficient memory usage and allow functions to modify caller's data. Essential for performance and reference semantics.", - "links": [] + "description": "Variables storing memory addresses of other variables. Declared with `*Type`, dereferenced with `*ptr`, address obtained with `&var`. Enable efficient memory usage and allow functions to modify caller's data. Essential for performance and reference semantics.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Pointers", + "url": "https://go.dev/tour/moretypes/1", + "type": "article" + }, + { + "title": "Complete Guide to Pointers in Go: From Basics to Best Practices", + "url": "https://www.willworth.dev/Go-Pointers", + "type": "article" + } + ] }, "NfYlEY8f_YPITT6Exp3Iw": { "title": "Pointers with Structs ", - "description": "Pointers to structs enable efficient passing of large structures and allow modification of struct fields. Access fields with `(*ptr).field` or shorthand `ptr.field`. Common for method receivers and when structs need to be modified by functions. Essential for memory efficiency.", - "links": [] + "description": "Pointers to structs enable efficient passing of large structures and allow modification of struct fields. Access fields with `(*ptr).field` or shorthand `ptr.field`. Common for method receivers and when structs need to be modified by functions. Essential for memory efficiency.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Pointers to structs", + "url": "https://go.dev/tour/moretypes/4", + "type": "article" + }, + { + "title": "When should I use pointer and struct in golang?", + "url": "https://medium.com/@wasiualhasib/working-with-structs-and-pointers-in-go-32a00a460cea", + "type": "article" + } + ] }, "oAvCO3GOKktkbmPahkPlT": { "title": "With Maps & Slices", - "description": "Maps and slices are reference types - passing them to functions doesn't copy underlying data. Modifications inside functions affect original. No need for explicit pointers. However, reassigning the slice/map variable itself won't affect caller unless using pointer.", - "links": [] + "description": "Maps and slices are reference types - passing them to functions doesn't copy underlying data. Modifications inside functions affect original. No need for explicit pointers. However, reassigning the slice/map variable itself won't affect caller unless using pointer.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Maps", + "url": "https://go.dev/blog/maps", + "type": "article" + }, + { + "title": "Pointers", + "url": "https://go.dev/tour/moretypes/1", + "type": "article" + }, + { + "title": "Slice Arrays Correctly", + "url": "https://labex.io/tutorials/go-how-to-slice-arrays-correctly-418936", + "type": "article" + }, + { + "title": "Complete Guide to Pointers in Go: From Basics to Best Practices", + "url": "https://www.willworth.dev/Go-Pointers", + "type": "article" + } + ] }, "ItMgLOzaUCCdiTk221pAF": { "title": "Memory Management", - "description": "Largely automatic through garbage collection. Runtime decides stack (fast, auto-cleaned) vs heap (slower, GC required) allocation via escape analysis. Understanding allocation patterns and avoiding memory leaks helps write efficient, scalable Go programs.", - "links": [] + "description": "Largely automatic through garbage collection. Runtime decides stack (fast, auto-cleaned) vs heap (slower, GC required) allocation via escape analysis. Understanding allocation patterns and avoiding memory leaks helps write efficient, scalable Go programs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "The Go Memory Model", + "url": "https://go.dev/ref/mem", + "type": "article" + }, + { + "title": "An overview of memory management in Go", + "url": "https://medium.com/safetycultureengineering/an-overview-of-memory-management-in-go-9a72ec7c76a8", + "type": "article" + }, + { + "title": "How Go Manages Memory and Why It's So Efficient", + "url": "https://medium.com/@siddharthnarayan/how-go-manages-memory-and-why-its-so-efficient-68c13133ba1c", + "type": "article" + } + ] }, "GG0j6MNVudvITHEOXUxim": { "title": "Garbage Collection", - "description": "Go's GC automatically reclaims unreachable memory using concurrent, tri-color mark-and-sweep collector designed for minimal pause times. Runs concurrently with your program. Understanding GC helps write efficient programs that work well with automatic memory management.", - "links": [] + "description": "Go's GC automatically reclaims unreachable memory using concurrent, tri-color mark-and-sweep collector designed for minimal pause times. Runs concurrently with your program. Understanding GC helps write efficient programs that work well with automatic memory management.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Garbage Collections", + "url": "https://tip.golang.org/doc/gc-guide", + "type": "article" + }, + { + "title": "Garbage Collection In Go", + "url": "https://www.ardanlabs.com/blog/2018/12/garbage-collection-in-go-part1-semantics.html", + "type": "article" + }, + { + "title": "Understanding Go's Garbage Collection", + "url": "https://bwoff.medium.com/understanding-gos-garbage-collection-415a19cc485c", + "type": "article" + } + ] }, "jx1vln8hqRJqVZfJi6CST": { "title": "Methods vs Functions", - "description": "Methods are functions with receiver arguments, defined outside type declaration. Enable object-like behavior on types. Functions are standalone, methods belong to specific types. Methods can have value or pointer receivers. Both can accept parameters and return values.", - "links": [] + "description": "Methods are functions with receiver arguments, defined outside type declaration. Enable object-like behavior on types. Functions are standalone, methods belong to specific types. Methods can have value or pointer receivers. Both can accept parameters and return values.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Methods", + "url": "https://go.dev/tour/methods/1", + "type": "article" + }, + { + "title": "Golang Methods Tutorial [Practical Examples]", + "url": "https://www.golinuxcloud.com/golang-methods/", + "type": "article" + }, + { + "title": "Golang Functions vs Methods, why and when to use them", + "url": "https://medium.com/@yuseferi/golang-functions-vs-methods-why-and-when-to-use-them-5b63fa1dc7f3", + "type": "article" + } + ] }, "6NKgb-OjGdT3QsMrDU05b": { "title": "Pointer Receivers", - "description": "Methods receive pointer to struct rather than copy using `func (p *Type) methodName()` syntax. Necessary when method modifies receiver state or struct is large. Go automatically handles value/pointer conversion when calling methods.", - "links": [] + "description": "Methods receive pointer to struct rather than copy using `func (p *Type) methodName()` syntax. Necessary when method modifies receiver state or struct is large. Go automatically handles value/pointer conversion when calling methods.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Pointer Receivers", + "url": "https://go.dev/tour/methods/4", + "type": "article" + }, + { + "title": "Understanding Value and Pointer Receivers in Golang", + "url": "https://medium.com/the-bug-shots/understanding-value-and-pointer-receivers-in-golang-82dd73a3eef9", + "type": "article" + }, + { + "title": "How to define methods with pointer receivers", + "url": "https://labex.io/tutorials/go-how-to-define-methods-with-pointer-receivers-437937", + "type": "article" + } + ] }, "99a4irV044ybZN-boMgHv": { "title": "Value Receivers", - "description": "Methods receive copy of struct rather than pointer. Use `func (v Type) methodName()` syntax. Appropriate when method doesn't modify receiver or struct is small. Can be called on both values and pointers with Go automatically dereferencing.", - "links": [] + "description": "Methods receive copy of struct rather than pointer. Use `func (v Type) methodName()` syntax. Appropriate when method doesn't modify receiver or struct is small. Can be called on both values and pointers with Go automatically dereferencing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Value Receivers", + "url": "https://go.dev/tour/methods/8", + "type": "article" + }, + { + "title": "Understanding Value and Pointer Receivers in Go Interfaces", + "url": "https://afdz.medium.com/understanding-value-and-pointer-receivers-in-go-interfaces-e97a824fdded", + "type": "article" + }, + { + "title": "Go Method Receivers: Understanding Value vs. Pointer and When to Use", + "url": "https://blog.stackademic.com/go-method-receivers-understanding-value-vs-pointer-and-when-to-use-each-74ef82d66a5c", + "type": "article" + } + ] }, "hIRMnPyHRGh8xCU8BTS2n": { "title": "Interfaces", - "description": "Define contracts specifying method signatures without implementation. Types satisfy interfaces implicitly by implementing required methods. Enable polymorphism and loose coupling. Empty interface `interface{}` accepts any type. Foundation of Go's type system and composition patterns.", - "links": [] + "description": "Define contracts specifying method signatures without implementation. Types satisfy interfaces implicitly by implementing required methods. Enable polymorphism and loose coupling. Empty interface `interface{}` accepts any type. Foundation of Go's type system and composition patterns.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Interfaces - Go by Example", + "url": "https://gobyexample.com/interfaces", + "type": "article" + }, + { + "title": "Mastering Go Interfaces: From Basics to Best Practices", + "url": "https://abubakardev0.medium.com/mastering-go-interfaces-from-basics-to-best-practices-36912b65aa3d", + "type": "article" + } + ] }, "ueJ7ndK2SKniDVjN2aUlO": { "title": "Empty Interfaces", - "description": "The empty interface `interface{}` can hold values of any type since every type implements at least zero methods. Used for generic programming before Go 1.18 generics. Requires type assertions or type switches to access underlying values. Common in APIs handling unknown data types.", - "links": [] + "description": "The empty interface `interface{}` can hold values of any type since every type implements at least zero methods. Used for generic programming before Go 1.18 generics. Requires type assertions or type switches to access underlying values. Common in APIs handling unknown data types.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Empty Interface", + "url": "https://go.dev/tour/methods/14", + "type": "article" + }, + { + "title": "Understanding the empty interface in Go", + "url": "https://dev.to/flrnd/understanding-the-empty-interface-in-go-4652", + "type": "article" + } + ] }, "wK7GNTbOsMNs0N_1N4-dU": { "title": "Embedding Interfaces", - "description": "Create new interfaces by combining existing ones, promoting composition and reusability. Embedded interface methods automatically included. Enables interface hierarchies from simpler, focused interfaces. Supports composition over inheritance for modular, extensible systems.", - "links": [] + "description": "Create new interfaces by combining existing ones, promoting composition and reusability. Embedded interface methods automatically included. Enables interface hierarchies from simpler, focused interfaces. Supports composition over inheritance for modular, extensible systems.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Struct Embedding", + "url": "https://gobyexample.com/struct-embedding", + "type": "article" + }, + { + "title": "Interfaces and Embedding in Golang (Go)", + "url": "https://dev.to/diwakarkashyap/interfaces-and-embedding-in-golang-go-2em4", + "type": "article" + } + ] }, "4EJ4WnH2HA3ci2uoqmNex": { "title": "Type Assertions", - "description": "Extract underlying concrete value from interface. Syntax: `value.(Type)` or `value, ok := value.(Type)` for safe assertion. Panics if type assertion fails without ok form. Essential for working with interfaces and empty interfaces.", - "links": [] + "description": "Extract underlying concrete value from interface. Syntax: `value.(Type)` or `value, ok := value.(Type)` for safe assertion. Panics if type assertion fails without ok form. Essential for working with interfaces and empty interfaces.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Type Assertions", + "url": "https://go.dev/tour/methods/15", + "type": "article" + }, + { + "title": "Type assertions and type switches in Golang", + "url": "https://www.educative.io/answers/type-assertions-and-type-switches-in-golang", + "type": "article" + }, + { + "title": "Mastering Type Assertion in Go", + "url": "https://medium.com/@jamal.kaksouri/mastering-type-assertion-in-go-a-comprehensive-guide-216864b4ea4d", + "type": "article" + } + ] }, "6r9XbwlBtHmJrhviG2cTD": { "title": "Type Switch", - "description": "Special form of switch statement that operates on types rather than values. Syntax: `switch v := i.(type)`. Used with interfaces to determine underlying concrete type. Each case specifies types to match. Essential for handling interface{} and polymorphic code.", - "links": [] + "description": "Special form of switch statement that operates on types rather than values. Syntax: `switch v := i.(type)`. Used with interfaces to determine underlying concrete type. Each case specifies types to match. Essential for handling interface{} and polymorphic code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Type Switch", + "url": "https://go.dev/tour/methods/16", + "type": "article" + }, + { + "title": "A Comprehensive Guide to Type Switches in Go", + "url": "https://thelinuxcode.com/golang-type-switch-examples/", + "type": "article" + }, + { + "title": "Chapter 4: Interface and Type Systems in Go", + "url": "https://medium.com/@omidahn/chapter-4-interface-and-type-systems-in-go-75b52392cc38", + "type": "article" + } + ] }, "nkONsPlFYCMqzWHTm_EPB": { "title": "Interfaces Basics", - "description": "Define contracts through method signatures. Types automatically satisfy interfaces by implementing required methods. Declared with `type InterfaceName interface{}` syntax. Enable polymorphism and flexible, testable code depending on behavior rather than concrete types.", - "links": [] + "description": "Define contracts through method signatures. Types automatically satisfy interfaces by implementing required methods. Declared with `type InterfaceName interface{}` syntax. Enable polymorphism and flexible, testable code depending on behavior rather than concrete types.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Understanding Interfaces in Go", + "url": "https://golang.ntxm.org/docs/structs-and-interfaces/understanding-interfaces-in-go/", + "type": "article" + }, + { + "title": "Interfaces - Go by Example", + "url": "https://gobyexample.com/interfaces", + "type": "article" + }, + { + "title": "Mastering Go Interfaces: From Basics to Best Practices", + "url": "https://abubakardev0.medium.com/mastering-go-interfaces-from-basics-to-best-practices-36912b65aa3d", + "type": "article" + } + ] }, "uEpTANOBHlFwCg5p44Lh0": { "title": "Generics", - "description": "Introduced in Go 1.18, allow functions and types to work with different data types while maintaining type safety. Enable reusable code without sacrificing performance. Use type parameters (square brackets) and constraints. Reduce code duplication while preserving strong typing.", - "links": [] + "description": "Introduced in Go 1.18, allow functions and types to work with different data types while maintaining type safety. Enable reusable code without sacrificing performance. Use type parameters (square brackets) and constraints. Reduce code duplication while preserving strong typing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Generic Functions", + "url": "https://go.dev/doc/tutorial/generics", + "type": "article" + }, + { + "title": "Understanding Generics", + "url": "https://blog.logrocket.com/understanding-generics-go-1-18/", + "type": "article" + } + ] }, "9EdDI0vJaEmz3XxXMrpX9": { "title": "Why Generics?", - "description": "Introduced in Go 1.18 to solve code duplication when working with multiple types. Before generics: separate functions per type, empty interfaces (losing type safety), or code generation. Enable type-safe, reusable code maintaining compile-time checking.", - "links": [] + "description": "Introduced in Go 1.18 to solve code duplication when working with multiple types. Before generics: separate functions per type, empty interfaces (losing type safety), or code generation. Enable type-safe, reusable code maintaining compile-time checking.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Generics", + "url": "https://go.dev/doc/tutorial/generics", + "type": "article" + }, + { + "title": "A walkthrough of type constraints in Go", + "url": "https://simonklee.dk/type-constraints", + "type": "article" + }, + { + "title": "Mastering Type Assertion in Go", + "url": "https://medium.com/@jamal.kaksouri/mastering-type-assertion-in-go-a-comprehensive-guide-216864b4ea4d", + "type": "article" + } + ] }, "p7L4EUsjMnJlrbb-oDvlf": { "title": "Generic Functions", - "description": "Write functions working with multiple types using type parameters in square brackets like `func FunctionName[T any](param T) T`. Enable reusable algorithms maintaining type safety. Particularly useful for utility functions and data processing that don't depend on specific types.", - "links": [] + "description": "Write functions working with multiple types using type parameters in square brackets like `func FunctionName[T any](param T) T`. Enable reusable algorithms maintaining type safety. Particularly useful for utility functions and data processing that don't depend on specific types.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Generic Functions", + "url": "https://go.dev/doc/tutorial/generics", + "type": "article" + }, + { + "title": "Generic Functions Comprehensive Guide", + "url": "https://www.ardanlabs.com/blog/2018/12/garbage-collection-in-go-part1-semantics.html", + "type": "article" + } + ] }, "eWZzradMaH57H4mI7Qw6n": { "title": "Generic Types / Interfaces", - "description": "Create reusable data structures and interface definitions working with multiple types. Define with type parameters like `type Container[T any] struct { value T }`. Enable type-safe containers, generic slices, maps, and custom structures while maintaining Go's strong typing.", - "links": [] + "description": "Create reusable data structures and interface definitions working with multiple types. Define with type parameters like `type Container[T any] struct { value T }`. Enable type-safe containers, generic slices, maps, and custom structures while maintaining Go's strong typing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Generic Functions", + "url": "https://go.dev/doc/tutorial/generics", + "type": "article" + }, + { + "title": "Interfaces", + "url": "https://golangdocs.com/interfaces-in-golang", + "type": "article" + }, + { + "title": "Understanding the Power of Go Interfaces", + "url": "https://medium.com/@jamal.kaksouri/understanding-the-power-of-go-interfaces-a-comprehensive-guide-835954101b7e", + "type": "article" + } + ] }, "8o6A2kGnupGYaaTwgsTDp": { "title": "Type Constraints", - "description": "Specify which types can be used as type arguments for generics. Defined using interfaces with method signatures or type sets. Common constraints include `any`, `comparable`, and custom constraints. Enable writing generic code that safely operates on type parameters.", - "links": [] + "description": "Specify which types can be used as type arguments for generics. Defined using interfaces with method signatures or type sets. Common constraints include `any`, `comparable`, and custom constraints. Enable writing generic code that safely operates on type parameters.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Generics", + "url": "https://go.dev/doc/tutorial/generics", + "type": "article" + }, + { + "title": "A walkthrough of type constraints in Go", + "url": "https://simonklee.dk/type-constraints", + "type": "article" + }, + { + "title": "Mastering Type Assertion in Go", + "url": "https://medium.com/@jamal.kaksouri/mastering-type-assertion-in-go-a-comprehensive-guide-216864b4ea4d", + "type": "article" + } + ] }, "36gt0FmNDxuIIV47aqBeH": { "title": "Type Inference", - "description": "Allows compiler to automatically determine generic type arguments based on function arguments or context. Reduces need for explicit type specification while maintaining type safety. Makes generic functions cleaner and more readable by eliminating redundant type specifications.", - "links": [] + "description": "Allows compiler to automatically determine generic type arguments based on function arguments or context. Reduces need for explicit type specification while maintaining type safety. Makes generic functions cleaner and more readable by eliminating redundant type specifications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Type Inference", + "url": "https://go.dev/blog/type-inference", + "type": "article" + }, + { + "title": "What Is Type Inference? What It Is and How It Work", + "url": "https://hackernoon.com/what-is-type-inference-what-it-is-and-how-it-works", + "type": "article" + }, + { + "title": "Chapter 4: Interface and Type Systems in Go", + "url": "https://medium.com/@omidahn/chapter-4-interface-and-type-systems-in-go-75b52392cc38", + "type": "article" + } + ] }, "7EKUfKx7_7lZOs3d84iyL": { "title": "Error Handling Basics", - "description": "Go uses explicit error handling with error return values. Functions return error as last value. Check `if err != nil` pattern. Create errors with `errors.New()` or `fmt.Errorf()`. No exceptions - errors are values to be handled explicitly.", - "links": [] + "description": "Go uses explicit error handling with error return values. Functions return error as last value. Check `if err != nil` pattern. Create errors with `errors.New()` or `fmt.Errorf()`. No exceptions - errors are values to be handled explicitly.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Error Handling and Go", + "url": "https://go.dev/blog/error-handling-and-go", + "type": "article" + }, + { + "title": "Mastering Error Handling in Go: A Comprehensive Guide", + "url": "https://medium.com/hprog99/mastering-error-handling-in-go-a-comprehensive-guide-fac34079833f", + "type": "article" + }, + { + "title": "Errors and Exception Handling in Golang", + "url": "https://golangdocs.com/errors-exception-handling-in-golang", + "type": "article" + } + ] }, "0mMP6QR0V-Zi25njD1TFT": { "title": "`error` interface", - "description": "Built-in interface with single `Error() string` method. Any type implementing this method can represent an error. Central to Go's error handling philosophy, providing consistent error representation across all Go code. Fundamental for effective error handling.", - "links": [] + "description": "Built-in interface with single `Error() string` method. Any type implementing this method can represent an error. Central to Go's error handling philosophy, providing consistent error representation across all Go code. Fundamental for effective error handling.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Error Handling and Go", + "url": "https://go.dev/blog/error-handling-and-go", + "type": "article" + }, + { + "title": "The Error Interface", + "url": "https://golang.ntxm.org/docs/error-handling-in-go/the-error-interface/", + "type": "article" + }, + { + "title": "Mastering Error Handling in Go: A Comprehensive Guide", + "url": "https://medium.com/hprog99/mastering-error-handling-in-go-a-comprehensive-guide-fac34079833f", + "type": "article" + }, + { + "title": "Errors and Exception Handling in Golang", + "url": "https://golangdocs.com/errors-exception-handling-in-golang", + "type": "article" + } + ] }, "dHk6Y0zFqxtCuDiQcHQsi": { "title": "errors.New", - "description": "Simplest way to create error values by taking a string message and returning an error implementing the error interface. Useful for simple, static error messages. Often combined with error wrapping or used for predefined error constants.", - "links": [] + "description": "Simplest way to create error values by taking a string message and returning an error implementing the error interface. Useful for simple, static error messages. Often combined with error wrapping or used for predefined error constants.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Error Handling and Go", + "url": "https://go.dev/blog/error-handling-and-go", + "type": "article" + }, + { + "title": "The Error Interface", + "url": "https://golang.ntxm.org/docs/error-handling-in-go/the-error-interface/", + "type": "article" + }, + { + "title": "Mastering Error Handling in Go: A Comprehensive Guide", + "url": "https://medium.com/hprog99/mastering-error-handling-in-go-a-comprehensive-guide-fac34079833f", + "type": "article" + }, + { + "title": "Creating Custom Errors in Go", + "url": "https://www.digitalocean.com/community/tutorials/creating-custom-errors-in-go", + "type": "article" + } + ] }, "LVaWjZfij6-z_uwkAc0MK": { "title": "fmt.Errorf", - "description": "Creates formatted error messages using printf-style verbs. Supports `%w` verb for error wrapping (Go 1.13+) to create error chains preserving original errors while adding context. Essential for descriptive errors with dynamic values and debugging information.", - "links": [] + "description": "Creates formatted error messages using printf-style verbs. Supports `%w` verb for error wrapping (Go 1.13+) to create error chains preserving original errors while adding context. Essential for descriptive errors with dynamic values and debugging information.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "fmt", + "url": "https://pkg.go.dev/fmt", + "type": "article" + }, + { + "title": "Error Handling and Go", + "url": "https://go.dev/blog/error-handling-and-go", + "type": "article" + }, + { + "title": "Mastering Error Handling in Golang: The Power of fmt.Errorf ()", + "url": "https://thelinuxcode.com/mastering-error-handling-in-golang-the-power-of-fmt-errorf/", + "type": "article" + }, + { + "title": "Understanding the fmt.Errorf Function in Golang", + "url": "https://www.zetcode.com/golang/fmt-errorf/", + "type": "article" + } + ] }, "s2WlOMMKNXf6O2Qiqcm_m": { "title": "Wrapping/Unwrapping Errors", - "description": "Create error chains preserving original errors while adding context using `fmt.Errorf()` with `%w` verb. Use `errors.Unwrap()`, `errors.Is()`, and `errors.As()` to work with wrapped errors. Enables rich error contexts for easier debugging.", - "links": [] + "description": "Create error chains preserving original errors while adding context using `fmt.Errorf()` with `%w` verb. Use `errors.Unwrap()`, `errors.Is()`, and `errors.As()` to work with wrapped errors. Enables rich error contexts for easier debugging.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Golang: error wrapping / unwrapping", + "url": "https://medium.com/@vajahatkareem/golang-error-wrapping-multierror-759d04bdbfaf", + "type": "article" + }, + { + "title": "Error Wrapping in Go - Go Error Handling Example", + "url": "https://go-cookbook.com/snippets/error-handling/error-wrapping", + "type": "article" + } + ] }, "vjfqq1XVS25FVe9smtel0": { "title": "Sentinel Errors", - "description": "Predefined error values representing specific conditions, defined as package-level variables. Check using `errors.Is()` or direct comparison. Examples: `io.EOF`. Enable predictable APIs where callers handle specific errors differently.", - "links": [] + "description": "Predefined error values representing specific conditions, defined as package-level variables. Check using `errors.Is()` or direct comparison. Examples: `io.EOF`. Enable predictable APIs where callers handle specific errors differently.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Select Statement", + "url": "https://go.dev/tour/concurrency/5", + "type": "article" + }, + { + "title": "Golang Sentinel Error", + "url": "https://www.tiredsg.dev/blog/golang-sentinel-error/", + "type": "article" + }, + { + "title": "Writing Clean Code in Go: Sentinel Errors", + "url": "https://medium.com/gopher-time/writing-clean-code-in-go-sentinel-errors-5ad93a30bc8e", + "type": "article" + } + ] }, "2KyzUjcMiMgo_AvlPjYbx": { "title": "`panic` and `recover`", - "description": "`panic()` stops execution and unwinds stack, `recover()` catches panics in deferred functions. Use sparingly for unrecoverable errors. While Go emphasizes explicit errors, panic/recover serve as safety net for exceptional situations.", - "links": [] + "description": "`panic()` stops execution and unwinds stack, `recover()` catches panics in deferred functions. Use sparingly for unrecoverable errors. While Go emphasizes explicit errors, panic/recover serve as safety net for exceptional situations.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Defer, Panic, and Recover", + "url": "https://go.dev/blog/defer-panic-and-recover", + "type": "article" + }, + { + "title": "Handling Panics in Go", + "url": "https://www.digitalocean.com/community/tutorials/handling-panics-in-go", + "type": "article" + } + ] }, "rR_BIgiSR63rVlO2Igzin": { "title": "Stack Traces & Debugging", - "description": "Go automatically prints stack traces on panic showing call chain. Tools include Delve debugger, pprof profiling, and race detection. Stack traces show function calls, file locations, and line numbers for effective troubleshooting.", - "links": [] + "description": "Go automatically prints stack traces on panic showing call chain. Tools include Delve debugger, pprof profiling, and race detection. Stack traces show function calls, file locations, and line numbers for effective troubleshooting.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Diagnostics", + "url": "https://go.dev/doc/diagnostics", + "type": "article" + }, + { + "title": "A Comprehensive Guide to Debugging Go Code for Developers", + "url": "https://dev.to/adityabhuyan/a-comprehensive-guide-to-debugging-go-code-for-developers-h9d", + "type": "article" + }, + { + "title": "Reading Go Stack Traces - Go Debugging Example", + "url": "https://go-cookbook.com/snippets/debugging/reading-go-stack-traces", + "type": "article" + } + ] }, "kep_536v13aS1V9XwHKSr": { "title": "Modules & Dependencies", - "description": "Go modules are the dependency management system introduced in Go 1.11. Define module with `go.mod` file containing module path and dependencies. Use `go get` to add dependencies, `go mod tidy` to clean up. Supports semantic versioning and replacement directives. Essential for modern Go development.", - "links": [] + "description": "Go modules are the dependency management system introduced in Go 1.11. Define module with `go.mod` file containing module path and dependencies. Use `go get` to add dependencies, `go mod tidy` to clean up. Supports semantic versioning and replacement directives. Essential for modern Go development.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go mod", + "url": "https://go.dev/doc/tutorial/create-module", + "type": "article" + }, + { + "title": "go mod reference", + "url": "https://go.dev/ref/mod", + "type": "article" + }, + { + "title": "go mod commands", + "url": "https://blog.devtrovert.com/p/go-get-go-mod-tidy-commands", + "type": "article" + }, + { + "title": "What does go mod tidy do?", + "url": "https://golangbyexamples.com/go-mod-tidy/", + "type": "article" + } + ] }, "zWXJOXo8dRnuTvYlWOL6r": { "title": "go mod init", - "description": "Initializes new Go module by creating `go.mod` file with specified module path (typically repository URL). Marks directory as module root and enables module-based dependency management. First step for any new Go project.", - "links": [] + "description": "Initializes new Go module by creating `go.mod` file with specified module path (typically repository URL). Marks directory as module root and enables module-based dependency management. First step for any new Go project.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go mod", + "url": "https://go.dev/doc/tutorial/create-module", + "type": "article" + }, + { + "title": "go mod reference", + "url": "https://go.dev/ref/mod", + "type": "article" + }, + { + "title": "Initiating Go Modules with Go Mod Init Explained Simply", + "url": "https://go.dev/blog/using-go-modules", + "type": "article" + } + ] }, "6rwVq1bMSHoGatEfm9hkp": { "title": "go mod tidy", - "description": "Ensures `go.mod` matches source code by adding missing requirements and removing unused dependencies. Updates `go.sum` with checksums. Essential for maintaining clean dependency management and ensuring reproducible builds before production deployment.", - "links": [] + "description": "Ensures `go.mod` matches source code by adding missing requirements and removing unused dependencies. Updates `go.sum` with checksums. Essential for maintaining clean dependency management and ensuring reproducible builds before production deployment.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go mod create", + "url": "https://go.dev/doc/tutorial/create-module", + "type": "article" + }, + { + "title": "go mod reference", + "url": "https://go.dev/ref/mod", + "type": "article" + }, + { + "title": "go mod commands", + "url": "https://blog.devtrovert.com/p/go-get-go-mod-tidy-commands", + "type": "article" + }, + { + "title": "What does go mod tidy do?", + "url": "https://golangbyexamples.com/go-mod-tidy/", + "type": "article" + } + ] }, "jOiAk5coeDNVXP2QiwQis": { "title": "go mod vendor", - "description": "Creates `vendor` directory with dependency copies for bundling with source code. Ensures builds work without internet access. Useful for deployment, air-gapped environments, and complete control over dependency availability.", - "links": [] + "description": "Creates `vendor` directory with dependency copies for bundling with source code. Ensures builds work without internet access. Useful for deployment, air-gapped environments, and complete control over dependency availability.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Vendoring, or go mod vendor: What Is It?", + "url": "https://victoriametrics.com/blog/vendoring-go-mod-vendor/", + "type": "article" + }, + { + "title": "go mod commands", + "url": "https://blog.devtrovert.com/p/go-get-go-mod-tidy-commands", + "type": "article" + }, + { + "title": "Go Modules and Vendors: Simplify Dependency Management", + "url": "https://mahmoudaljadan.medium.com/go-modules-and-vendors-simplify-dependency-management-in-your-golang-project-a29689eb26b1", + "type": "article" + } + ] }, "AcYzrGFrwmeVYFEfhEiSZ": { "title": "Packages", - "description": "Fundamental unit of code organization in Go. Group related functions, types, and variables. Defined by package declaration at file top. Exported names start with capital letters. Import with `import` statement. Enable modularity, reusability, and namespace management.", - "links": [] + "description": "Fundamental unit of code organization in Go. Group related functions, types, and variables. Defined by package declaration at file top. Exported names start with capital letters. Import with `import` statement. Enable modularity, reusability, and namespace management.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "os package", + "url": "https://pkg.go.dev/os", + "type": "article" + }, + { + "title": "Importing Packages in Go", + "url": "https://www.digitalocean.com/community/tutorials/importing-packages-in-go", + "type": "article" + }, + { + "title": "A Comprehensive Guide to Importing and Using Packages", + "url": "https://learnscripting.org/a-comprehensive-guide-to-importing-and-using-packages-in-go/", + "type": "article" + } + ] }, "dA8SMhCev1NWNM1Tsxu57": { "title": "Package Import Rules", - "description": "Key rules: no circular imports, main package for executables, lowercase package names, exported identifiers start with capitals. Import paths are unique identifiers. Understanding ensures proper structure and follows Go conventions.", - "links": [] + "description": "Key rules: no circular imports, main package for executables, lowercase package names, exported identifiers start with capitals. Import paths are unique identifiers. Understanding ensures proper structure and follows Go conventions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "os package", + "url": "https://pkg.go.dev/os", + "type": "article" + }, + { + "title": "Importing Packages in Go", + "url": "https://www.digitalocean.com/community/tutorials/importing-packages-in-go", + "type": "article" + }, + { + "title": "A Comprehensive Guide to Importing and Using Packages", + "url": "https://learnscripting.org/a-comprehensive-guide-to-importing-and-using-packages-in-go/", + "type": "article" + } + ] }, "eBv3i2cNA7vc01jLAbB8m": { "title": "Using 3rd Party Packages", - "description": "Import external libraries using `go get package-url` which updates `go.mod`. Consider maintenance status, documentation, license, and security when choosing packages. Go modules handle version management and ensure reproducible builds.", - "links": [] + "description": "Import external libraries using `go get package-url` which updates `go.mod`. Consider maintenance status, documentation, license, and security when choosing packages. Go modules handle version management and ensure reproducible builds.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Import and Use a Third-Party Package in Golang", + "url": "https://thenewstack.io/import-and-use-a-third-party-package-in-golang/", + "type": "article" + }, + { + "title": "Using Third-Party Packages and Libraries in Golang", + "url": "https://medium.com/@bramahendramahendra1/using-third-party-packages-and-libraries-in-golang-efbf0046f574", + "type": "article" + } + ] }, "CysLmwRqmQzOGAKM01AKF": { "title": "Publishing Modules", - "description": "Share Go code through version control systems using semantic versioning tags. Go proxy system automatically discovers and serves modules. Follow Go conventions, maintain documentation, and ensure backward compatibility to contribute to the ecosystem.", - "links": [] + "description": "Share Go code through version control systems using semantic versioning tags. Go proxy system automatically discovers and serves modules. Follow Go conventions, maintain documentation, and ensure backward compatibility to contribute to the ecosystem.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Publishing Modules", + "url": "https://go.dev/doc/modules/publishing", + "type": "article" + }, + { + "title": "How To Create & Publish a Go Public Package", + "url": "https://medium.com/the-godev-corner/how-to-create-publish-a-go-public-package-9034e6bfe4a9", + "type": "article" + } + ] }, "08QOxnF3rKEDekrkX7w1j": { "title": "Goroutines", - "description": "Lightweight threads managed by Go runtime enabling concurrent function execution. Created with `go` keyword prefix. Minimal memory overhead, can run thousands/millions concurrently. Runtime handles scheduling across CPU cores. Communicate through channels, fundamental to Go's concurrency.", - "links": [] + "description": "Lightweight threads managed by Go runtime enabling concurrent function execution. Created with `go` keyword prefix. Minimal memory overhead, can run thousands/millions concurrently. Runtime handles scheduling across CPU cores. Communicate through channels, fundamental to Go's concurrency.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Goroutines", + "url": "https://go.dev/tour/concurrency/1", + "type": "article" + }, + { + "title": "Goroutines - Concurrency in Golang", + "url": "https://golangbot.com/goroutines/", + "type": "article" + }, + { + "title": "Goroutines in Golang: Understanding and Implementing", + "url": "https://medium.com/@jamal.kaksouri/goroutines-in-golang-understanding-and-implementing-concurrent-programming-in-go-600187bcfaa2", + "type": "article" + } + ] }, "EgXagvLpJkXUI2od5K1FD": { "title": "Channels", - "description": "Primary mechanism for goroutine communication following \"share memory by communicating\" principle. Typed conduits created with `make()`. Come in buffered and unbuffered varieties. Used for synchronization, data passing, and coordinating concurrent operations. Essential for concurrent programming.", - "links": [] + "description": "Primary mechanism for goroutine communication following \"share memory by communicating\" principle. Typed conduits created with `make()`. Come in buffered and unbuffered varieties. Used for synchronization, data passing, and coordinating concurrent operations. Essential for concurrent programming.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Channels in Golang", + "url": "https://golangdocs.com/channels-in-golang", + "type": "article" + }, + { + "title": "Concurrency in Go: Channels and WaitGroups", + "url": "https://medium.com/goturkiye/concurrency-in-go-channels-and-waitgroups-25dd43064d1", + "type": "article" + }, + { + "title": "Go Channels Explained: More than Just a Beginner's Guide", + "url": "https://blog.devtrovert.com/p/go-channels-explained-more-than-just", + "type": "article" + } + ] }, "4_nvU_YOs9Psey5TZLQFb": { "title": "Buffered vs Unbuffered", - "description": "Unbuffered channels provide synchronous communication - sender blocks until receiver ready. Buffered channels allow asynchronous communication up to capacity. Unbuffered for coordination/sequencing, buffered for performance/decoupling. Critical distinction for concurrent system design.", - "links": [] + "description": "Unbuffered channels provide synchronous communication - sender blocks until receiver ready. Buffered channels allow asynchronous communication up to capacity. Unbuffered for coordination/sequencing, buffered for performance/decoupling. Critical distinction for concurrent system design.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Advanced Insights into Go Channels", + "url": "https://medium.com/@aditimishra_541/advanced-insights-into-go-channels-unbuffered-and-buffered-channels-d76d705bcc24", + "type": "article" + }, + { + "title": "Buffered vs Unbuffered Channels in Golang", + "url": "https://dev.to/akshitzatakia/buffered-vs-unbuffered-channels-in-golang-a-developers-guide-to-concurrency-3m75", + "type": "article" + } + ] }, "RBr1uAdngIsvSpIdHHOyV": { "title": "Select Statement", - "description": "Multiplexer for channel operations. Waits on multiple channel operations simultaneously, executing first one ready. Supports send/receive operations, default case for non-blocking behavior. Essential for coordinating multiple goroutines and implementing timeouts.", - "links": [] + "description": "Multiplexer for channel operations. Waits on multiple channel operations simultaneously, executing first one ready. Supports send/receive operations, default case for non-blocking behavior. Essential for coordinating multiple goroutines and implementing timeouts.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Select Statement", + "url": "https://go.dev/tour/concurrency/5", + "type": "article" + }, + { + "title": "Select Statement in Go (Golang)", + "url": "https://golangbyexamples.com/select-statement-golang/", + "type": "article" + }, + { + "title": "Go (Golang) Select Tutorial with Practical Examples", + "url": "https://golangbot.com/select/", + "type": "article" + } + ] }, "z8ItWHAupaastLcXY3npY": { "title": "Worker Pools", - "description": "Concurrency pattern using fixed number of goroutines to process tasks from shared queue. Controls resource usage while maintaining parallelism. Typically implemented with buffered channels for task distribution and WaitGroups for synchronization. Ideal for CPU-bound tasks and rate limiting.", - "links": [] + "description": "Concurrency pattern using fixed number of goroutines to process tasks from shared queue. Controls resource usage while maintaining parallelism. Typically implemented with buffered channels for task distribution and WaitGroups for synchronization. Ideal for CPU-bound tasks and rate limiting.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "GO: How to Write a Worker Pool", + "url": "https://dev.to/justlorain/go-how-to-write-a-worker-pool-1h3b", + "type": "article" + }, + { + "title": "Efficient Concurrency in Go: A Deep Dive into the Worker Pool", + "url": "https://rksurwase.medium.com/efficient-concurrency-in-go-a-deep-dive-into-the-worker-pool-pattern-for-batch-processing-73cac5a5bdca", + "type": "article" + } + ] }, "nOI0juYhqJXNTiJBU4bKH": { "title": "`sync` Package", - "description": "Provides synchronization primitives for coordinating goroutines and safe concurrent access. Includes Mutex (mutual exclusion), RWMutex (reader-writer locks), WaitGroup (waiting on goroutines), Once (one-time init). Essential for avoiding race conditions.", - "links": [] + "description": "Provides synchronization primitives for coordinating goroutines and safe concurrent access. Includes Mutex (mutual exclusion), RWMutex (reader-writer locks), WaitGroup (waiting on goroutines), Once (one-time init). Essential for avoiding race conditions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "sync package", + "url": "https://pkg.go.dev/sync", + "type": "article" + }, + { + "title": "Golang Sync Package", + "url": "https://medium.com/@asgrr/golang-sync-4787b18fee41", + "type": "article" + }, + { + "title": "Use of synchronization techniques in Golang", + "url": "https://lebum.medium.com/use-of-synchronization-techniques-in-golang-53d75bc0a646", + "type": "article" + } + ] }, "6ydgmac11Zu9Ithe0kKj9": { "title": "Mutexes", - "description": "Mutual exclusion locks from sync package ensuring only one goroutine accesses shared resource at a time. Use `Lock()` before and `Unlock()` after critical section. RWMutex allows multiple readers or single writer. Essential for protecting shared data from race conditions.", - "links": [] + "description": "Mutual exclusion locks from sync package ensuring only one goroutine accesses shared resource at a time. Use `Lock()` before and `Unlock()` after critical section. RWMutex allows multiple readers or single writer. Essential for protecting shared data from race conditions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "What is Mutex and How to Use it in Golang?", + "url": "https://dev.to/lincemathew/what-is-mutex-and-how-to-use-it-in-golang-1m1i", + "type": "article" + }, + { + "title": "Understanding Mutex in Go Introduction", + "url": "https://kamnagarg-10157.medium.com/understanding-mutex-in-go-5f41199085b9", + "type": "article" + } + ] }, "amqOwSgVFDymAsDIobwiK": { "title": "WaitGroups", - "description": "Synchronization primitive from sync package for waiting on multiple goroutines to complete. Use `Add()` to increment counter, `Done()` when goroutine finishes, `Wait()` to block until counter reaches zero. Essential for coordinating goroutine completion in concurrent programs.", - "links": [] + "description": "Synchronization primitive from sync package for waiting on multiple goroutines to complete. Use `Add()` to increment counter, `Done()` when goroutine finishes, `Wait()` to block until counter reaches zero. Essential for coordinating goroutine completion in concurrent programs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "WaitGroup in Go - How and when to use WaitGroup", + "url": "https://medium.com/@dmytro.misik/waitgroup-in-go-df8f068e646f", + "type": "article" + }, + { + "title": "Mastering Concurrency in Golang", + "url": "https://thelinuxcode.com/mastering-concurrency-in-golang-a-deep-dive-into-the-waitgroup/", + "type": "article" + } + ] }, "vxB3aGreqWBrNhiu8hcPE": { "title": "`context` Package", - "description": "Carries deadlines, cancellation signals, and request-scoped values across API boundaries. Essential for robust concurrent applications, especially web services. Enables cancelling long-running operations, setting timeouts, passing request data. Typically first parameter passed down call stack.", - "links": [] + "description": "Carries deadlines, cancellation signals, and request-scoped values across API boundaries. Essential for robust concurrent applications, especially web services. Enables cancelling long-running operations, setting timeouts, passing request data. Typically first parameter passed down call stack.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Concurrency Patterns: Context", + "url": "https://go.dev/blog/context", + "type": "article" + }, + { + "title": "The Complete Guide to Context in Golang", + "url": "https://medium.com/@jamal.kaksouri/the-complete-guide-to-context-in-golang-efficient-concurrency-management-43d722f6eaea", + "type": "article" + } + ] }, "p5u2tWRmRtyfBgKcSUHFU": { "title": "Deadlines & Cancellations", - "description": "Context package mechanisms for controlling operation lifetime and propagating cancellation signals. Supports deadlines (absolute time) or timeouts (duration). Functions should check `ctx.Done()` and return early when cancelled. Essential for robust concurrent applications.", - "links": [] + "description": "Context package mechanisms for controlling operation lifetime and propagating cancellation signals. Supports deadlines (absolute time) or timeouts (duration). Functions should check `ctx.Done()` and return early when cancelled. Essential for robust concurrent applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Canceling in-progress Operations", + "url": "https://go.dev/doc/database/cancel-operations", + "type": "article" + }, + { + "title": "Understanding Golang Context: Cancellation, Timeouts", + "url": "https://webdevstation.com/posts/understanding-golang-context/", + "type": "article" + }, + { + "title": "Understanding Context in Golang", + "url": "https://medium.com/better-programming/understanding-context-in-golang-7f574d9d94e0", + "type": "article" + }, + { + "title": "How to use the context.Done() method in Go", + "url": "https://dev.to/mcaci/how-to-use-the-context-done-method-in-go-22me", + "type": "article" + } + ] }, "gChqUzY3SbPJH0H0jcoAp": { "title": "Common Usecases", - "description": "Context package common uses: HTTP timeouts, database deadlines, goroutine cancellation coordination, and request-scoped values. Essential for web servers, microservices, circuit breakers, and building responsive APIs that handle cancellation gracefully.", - "links": [] + "description": "Context package common uses: HTTP timeouts, database deadlines, goroutine cancellation coordination, and request-scoped values. Essential for web servers, microservices, circuit breakers, and building responsive APIs that handle cancellation gracefully.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Use Cases", + "url": "https://go.dev/solutions/use-cases", + "type": "article" + }, + { + "title": "The Versatility of Go: Ideal Use Cases for the Golang Programming", + "url": "https://dev.to/adityabhuyan/the-versatility-of-go-ideal-use-cases-for-the-golang-programming-language-7co", + "type": "article" + } + ] }, "2yKVKaCXrcv5X4o2d6oqm": { "title": "Concurrency Patterns", - "description": "Established design approaches for structuring concurrent programs using goroutines and channels. Key patterns: fan-in (merging inputs), fan-out (distributing work), pipelines (chaining operations), worker pools, pub-sub communication. Help build efficient, scalable apps while avoiding race conditions and deadlocks.", - "links": [] + "description": "Established design approaches for structuring concurrent programs using goroutines and channels. Key patterns: fan-in (merging inputs), fan-out (distributing work), pipelines (chaining operations), worker pools, pub-sub communication. Help build efficient, scalable apps while avoiding race conditions and deadlocks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Concurrency Patterns: Pipelines and Cancellation", + "url": "https://go.dev/blog/pipelines", + "type": "article" + }, + { + "title": "Go Concurrency Patterns: A Deep Dive", + "url": "https://medium.com/@gopinathr143/go-concurrency-patterns-a-deep-dive-a2750f98a102", + "type": "article" + }, + { + "title": "Mastering Concurrency in Go", + "url": "https://dev.to/santoshanand/mastering-concurrency-in-go-a-comprehensive-guide-5chi", + "type": "article" + } + ] }, "8BrnnM7HM-bijbUDgnW49": { "title": "fan-in", - "description": "Concurrency pattern merging multiple input channels into single output channel. Allows collecting results from multiple goroutines. Typically implemented with select statement or separate goroutines for each input. Useful for aggregating parallel processing results.", - "links": [] + "description": "Concurrency pattern merging multiple input channels into single output channel. Allows collecting results from multiple goroutines. Typically implemented with select statement or separate goroutines for each input. Useful for aggregating parallel processing results.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fan Out Fan In Concurrency Pattern Explained", + "url": "https://www.golinuxcloud.com/go-fan-out-fan-in/", + "type": "article" + }, + { + "title": "Golang Concurrency Patterns: Fan in, Fan out", + "url": "https://medium.com/geekculture/golang-concurrency-patterns-fan-in-fan-out-1ee43c6830c4", + "type": "article" + } + ] }, "pN8EsuKUPDUKyskodu_sC": { "title": "fan-out", - "description": "Concurrency pattern distributing work from single source to multiple workers. Typically uses one input channel feeding multiple goroutines. Each worker processes items independently. Useful for parallelizing CPU-intensive tasks and increasing throughput through parallel processing.", - "links": [] + "description": "Concurrency pattern distributing work from single source to multiple workers. Typically uses one input channel feeding multiple goroutines. Each worker processes items independently. Useful for parallelizing CPU-intensive tasks and increasing throughput through parallel processing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fan Out Fan In Concurrency Pattern Explained", + "url": "https://www.golinuxcloud.com/go-fan-out-fan-in/", + "type": "article" + }, + { + "title": "Golang Concurrency Patterns: Fan in, Fan out", + "url": "https://medium.com/geekculture/golang-concurrency-patterns-fan-in-fan-out-1ee43c6830c4", + "type": "article" + } + ] }, "loozcCzPzkni7BOdcvt1S": { "title": "pipeline", - "description": "Concurrency pattern chaining processing stages where output of one stage becomes input of next. Each stage runs concurrently using goroutines and channels. Enables parallel processing and separation of concerns. Common in data processing, transformation workflows, and streaming applications.", - "links": [] + "description": "Concurrency pattern chaining processing stages where output of one stage becomes input of next. Each stage runs concurrently using goroutines and channels. Enables parallel processing and separation of concerns. Common in data processing, transformation workflows, and streaming applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Concurrency Pipelines", + "url": "https://go.dev/blog/pipelines", + "type": "article" + }, + { + "title": "Pipeline Pattern in Go: A Practical Guide", + "url": "https://dev.to/leapcell/pipeline-pattern-in-go-a-practical-guide-5dmm", + "type": "article" + }, + { + "title": "Applying Modern Go Concurrency Patterns to Data Pipelines", + "url": "https://medium.com/amboss/applying-modern-go-concurrency-patterns-to-data-pipelines-b3b5327908d4", + "type": "article" + } + ] }, "GoV8yaQARJmO47e0_l_GY": { "title": "Race Detection", - "description": "Built-in tool for detecting race conditions in concurrent programs. Enabled with `-race` flag during build/test/run. Detects unsynchronized access to shared variables from multiple goroutines. Performance overhead in race mode. Essential for debugging concurrent code safety.", - "links": [] + "description": "Built-in tool for detecting race conditions in concurrent programs. Enabled with `-race` flag during build/test/run. Detects unsynchronized access to shared variables from multiple goroutines. Performance overhead in race mode. Essential for debugging concurrent code safety.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Race Detection", + "url": "https://go.dev/doc/articles/race_detector", + "type": "article" + }, + { + "title": "Go: Race Detector with ThreadSanitizer", + "url": "https://medium.com/a-journey-with-go/go-race-detector-with-threadsanitizer-8e497f9e42db", + "type": "article" + }, + { + "title": "Data Race Detection and Data Race Patterns in Golang", + "url": "https://www.sobyte.net/post/2022-06/go-data-race/", + "type": "article" + } + ] }, "-Qy9DEWVYUNRHWiXXhIWU": { "title": "Standard Library", - "description": "Comprehensive collection of packages providing core functionality. Includes I/O, networking, text processing, cryptography, testing, JSON handling, HTTP client/server. Rich ecosystem reducing need for external dependencies. Well-documented, tested, and performance-optimized packages.", - "links": [] + "description": "Comprehensive collection of packages providing core functionality. Includes I/O, networking, text processing, cryptography, testing, JSON handling, HTTP client/server. Rich ecosystem reducing need for external dependencies. Well-documented, tested, and performance-optimized packages.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "std package", + "url": "https://pkg.go.dev/stds", + "type": "article" + }, + { + "title": "Building Robust APIs with Go's Standard Library", + "url": "https://dev.to/aaravjoshi/building-robust-apis-with-gos-standard-library-a-comprehensive-guide-3036", + "type": "article" + }, + { + "title": "How to use standard library packages in Golang", + "url": "https://labex.io/tutorials/go-how-to-use-standard-library-packages-in-golang-446140", + "type": "article" + } + ] }, "7SYEXD5r9WKEDfecQdO5d": { "title": "I/O & File Handling", - "description": "Go's I/O system provides comprehensive file and stream handling through `io` package interfaces (Reader, Writer, Closer) and `os` package file operations. The interface-based design allows working with files, network connections, and buffers using consistent patterns.", - "links": [] + "description": "Go's I/O system provides comprehensive file and stream handling through `io` package interfaces (Reader, Writer, Closer) and `os` package file operations. The interface-based design allows working with files, network connections, and buffers using consistent patterns.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Building High-Performance File Processing Pipelines in Go", + "url": "https://dev.to/aaravjoshi/building-high-performance-file-processing-pipelines-in-go-a-complete-guide-3opm", + "type": "article" + }, + { + "title": "Mastering File I/O in Go: A Complete Guide", + "url": "https://thelinuxcode.com/golang-os-open/", + "type": "article" + }, + { + "title": "Golang Fundamentals: File Handling and I/O", + "url": "https://medium.com/@nagarjun_nagesh/golang-fundamentals-file-handling-and-i-o-502d50b96795", + "type": "article" + } + ] }, "-8E79Ns4q-uAgcxtghPzf": { "title": "flag", - "description": "Standard library package for parsing command-line flags. Supports string, int, bool, duration flags with default values and descriptions. Automatically generates help text. Simple API for basic CLI argument parsing before using frameworks like Cobra.", - "links": [] + "description": "Standard library package for parsing command-line flags. Supports string, int, bool, duration flags with default values and descriptions. Automatically generates help text. Simple API for basic CLI argument parsing before using frameworks like Cobra.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Flag", + "url": "https://go-language.org/go-docs/flag/", + "type": "article" + }, + { + "title": "How To Use the Flag Package", + "url": "https://www.digitalocean.com/community/tutorials/how-to-use-the-flag-package-in-go", + "type": "article" + }, + { + "title": "Advanced Golang Flag Techniques", + "url": "https://www.golinuxcloud.com/golang-flags-examples/", + "type": "article" + } + ] }, "aK9EQO1JR9hYIMkS3mdai": { "title": "time", - "description": "Standard library package for time and date operations. Handles parsing, formatting, arithmetic, timers, tickers, and timezone operations. Key types: Time, Duration, Location. Supports RFC3339 format, custom layouts, time zones. Essential for scheduling, timeouts, timestamps.", - "links": [] + "description": "Standard library package for time and date operations. Handles parsing, formatting, arithmetic, timers, tickers, and timezone operations. Key types: Time, Duration, Location. Supports RFC3339 format, custom layouts, time zones. Essential for scheduling, timeouts, timestamps.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "time package", + "url": "https://pkg.go.dev/time", + "type": "article" + }, + { + "title": "How To Use Dates and Times in Go", + "url": "https://www.digitalocean.com/community/tutorials/how-to-use-dates-and-times-in-go", + "type": "article" + }, + { + "title": "Time in Go: Overview with Examples", + "url": "https://medium.com/@rakeshmirji/time-in-go-overview-with-examples-ebb9e30cdb45", + "type": "article" + } + ] }, "uB1fE15OprBcwN7p7ffJF": { "title": "encoding/json", - "description": "", - "links": [] + "description": "This package provides robust and efficient functionalities for marshaling (encoding) Go data structures into JSON and unmarshaling (decoding) JSON into Go data structures. This process is largely handled through the json.Marshal and json.Unmarshal functions. For a Go struct to be properly encoded or decoded, its fields must be exported (start with an uppercase letter). Developers can control the JSON field names and omit empty fields using struct tags like json:\"fieldName,omitempty\".\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Empty Interface", + "url": "https://go.dev/tour/methods/14", + "type": "article" + }, + { + "title": "Understanding the empty interface in Go", + "url": "https://dev.to/flrnd/understanding-the-empty-interface-in-go-4652", + "type": "article" + } + ] }, "9S1gkzBvt32uLy0IFZjrg": { "title": "os", - "description": "Standard library package providing operating system interface. Handles file operations, environment variables, process management, and system information. Includes functions for file I/O, directory operations, process control, and cross-platform OS interactions. Essential for system programming.", - "links": [] + "description": "Standard library package providing operating system interface. Handles file operations, environment variables, process management, and system information. Includes functions for file I/O, directory operations, process control, and cross-platform OS interactions. Essential for system programming.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "os package", + "url": "https://pkg.go.dev/os", + "type": "article" + }, + { + "title": "An Overview of Go's os and io Packages", + "url": "https://reintech.io/blog/an-overview-of-gos-os-and-io-packages", + "type": "article" + } + ] }, "Z8j6Zkg1LYEYcoRgs23Ms": { "title": "bufio", - "description": "Provides buffered I/O operations wrapping io.Reader/Writer interfaces for better performance. Reduces system calls by reading/writing larger chunks. Includes Scanner for line reading, Reader for buffered reading, Writer for buffered writing. Essential for efficient large file/network operations.", - "links": [] + "description": "Provides buffered I/O operations wrapping io.Reader/Writer interfaces for better performance. Reduces system calls by reading/writing larger chunks. Includes Scanner for line reading, Reader for buffered reading, Writer for buffered writing. Essential for efficient large file/network operations.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Bufio", + "url": "https://go.dev/src/bufio/bufio.go", + "type": "article" + }, + { + "title": "Bufio Package", + "url": "https://pkg.go.dev/bufio", + "type": "article" + }, + { + "title": "Go Fast with bufio: Unlocking the Power of Buffered I/O", + "url": "https://medium.com/@emusbeny/mastering-bufio-in-go-the-art-of-buffered-i-o-17cae584ee4b", + "type": "article" + } + ] }, "hFlbSSBMcJtjXNL8jAcbc": { "title": "slog", - "description": "Structured logging package introduced in Go 1.21. Provides leveled, structured logging with JSON output support. Better than basic log package for production use. Supports custom handlers, context integration, and performance optimization. Modern replacement for traditional logging.", - "links": [] + "description": "Structured logging package introduced in Go 1.21. Provides leveled, structured logging with JSON output support. Better than basic log package for production use. Supports custom handlers, context integration, and performance optimization. Modern replacement for traditional logging.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Structured Logging with slog", + "url": "https://go.dev/blog/slog", + "type": "article" + }, + { + "title": "Logging in Go with Slog: The Ultimate Guide", + "url": "https://betterstack.com/community/guides/logging/logging-in-go/", + "type": "article" + }, + { + "title": "Effective Logging in Go: Best Practices and Implementation", + "url": "https://dev.to/fazal_mansuri_/effective-logging-in-go-best-practices-and-implementation-guide-23hp", + "type": "article" + } + ] }, "9K5ffACdKNPJiWPq4tUWD": { "title": "regexp", - "description": "Standard library package for regular expression functionality. Implements RE2 syntax for safe, efficient pattern matching. Provides functions for matching, finding, replacing text patterns. Supports compiled expressions for performance. Essential for text processing, validation, parsing.", - "links": [] + "description": "Standard library package for regular expression functionality. Implements RE2 syntax for safe, efficient pattern matching. Provides functions for matching, finding, replacing text patterns. Supports compiled expressions for performance. Essential for text processing, validation, parsing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "regexp package", + "url": "https://pkg.go.dev/regexp", + "type": "article" + }, + { + "title": "Mastering Regular Expressions in Golang", + "url": "https://labex.io/tutorials/go-golang-regular-expression-tutorial-15502", + "type": "article" + }, + { + "title": "A deep dive into regular expressions with Golang", + "url": "https://blog.logrocket.com/deep-dive-regular-expressions-golang/", + "type": "article" + } + ] }, "iIPk-jK1vBCG_rKI_MPiu": { "title": "go:embed for embedding", - "description": "The `go:embed` directive embeds files and directories into Go binaries at compile time using `//go:embed` comments. Useful for including static assets, configs, and templates directly in executables, creating self-contained binaries that don't require external files.", - "links": [] + "description": "The `go:embed` directive embeds files and directories into Go binaries at compile time using `//go:embed` comments. Useful for including static assets, configs, and templates directly in executables, creating self-contained binaries that don't require external files.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go embed", + "url": "https://pkg.go.dev/embed", + "type": "article" + }, + { + "title": "A Guide to Embedding Static Files in Go", + "url": "https://www.iamyadav.com/blogs/a-guide-to-embedding-static-files-in-go", + "type": "article" + }, + { + "title": "How to Use go:embed in Go?", + "url": "https://www.scaler.com/topics/golang/golang-embed/", + "type": "article" + } + ] }, "nZkLFmm2GENL81y5LB0c1": { "title": "`testing` package basics", - "description": "Standard library package for writing tests. Test functions start with `Test` and take `*testing.T` parameter. Use `t.Error()`, `t.Fatal()` for failures. Test files end with `_test.go`. Run with `go test`. Supports benchmarks and examples.", - "links": [] + "description": "Standard library package for writing tests. Test functions start with `Test` and take `*testing.T` parameter. Use `t.Error()`, `t.Fatal()` for failures. Test files end with `_test.go`. Run with `go test`. Supports benchmarks and examples.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "testing package", + "url": "https://pkg.go.dev/testing", + "type": "article" + }, + { + "title": "How to manage testing package setup", + "url": "https://labex.io/tutorials/go-how-to-manage-testing-package-setup-451557", + "type": "article" + }, + { + "title": "Go Unit Testing: A Practical Guide for Writing Reliable Tests", + "url": "https://www.ceos3c.com/golang/go-unit-testing-a-practical-guide-for-writing-reliable-tests/", + "type": "article" + } + ] }, "6-mr65JzXbRzIukE7jzoZ": { "title": "Table-driven Tests", - "description": "Table-driven tests use slices of test cases to test multiple scenarios with the same logic. Each case contains inputs and expected outputs. Makes adding test cases easy and provides comprehensive coverage with minimal code duplication.", - "links": [] + "description": "Table-driven tests use slices of test cases to test multiple scenarios with the same logic. Each case contains inputs and expected outputs. Makes adding test cases easy and provides comprehensive coverage with minimal code duplication.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "TableDrivenTests", + "url": "https://go.dev/wiki/TableDrivenTests", + "type": "article" + }, + { + "title": "Table Driven Unit Tests in Go", + "url": "https://dev.to/boncheff/table-driven-unit-tests-in-go-407b", + "type": "article" + }, + { + "title": "Testing in Go with table drive tests and Testify", + "url": "https://dev.to/zpeters/testing-in-go-with-table-drive-tests-and-testify-kd4", + "type": "article" + } + ] }, "LjLbm4JEZ19howOkju7zQ": { "title": "Mocks and Stubs", - "description": "Mocks and stubs replace dependencies with controlled implementations for isolated testing. Stubs provide predefined responses while mocks verify method calls. Go's interfaces make mocking natural. Essential for testing without external dependencies.", - "links": [] + "description": "Mocks and stubs replace dependencies with controlled implementations for isolated testing. Stubs provide predefined responses while mocks verify method calls. Go's interfaces make mocking natural. Essential for testing without external dependencies.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Effective Testing in Go: Mocks and Stubs", + "url": "https://medium.com/@septio/effective-testing-in-go-mocks-and-stubs-ce22593e7b60", + "type": "article" + }, + { + "title": "Mock Solutions for Golang Unit Test", + "url": "https://laiyuanyuan-sg.medium.com/mock-solutions-for-golang-unit-test-a2b60bd3e157", + "type": "article" + }, + { + "title": "Writing unit tests in Golang Part 2: Mocking", + "url": "https://medium.com/nerd-for-tech/writing-unit-tests-in-golang-part-2-mocking-d4fa1701a3ae", + "type": "article" + }, + { + "title": "Mocks (Mocking), Stubs, and Fakes in Software Testing", + "url": "https://www.youtube.com/watch?v=Ir7dl7XX9r4", + "type": "video" + } + ] }, "Zt4FpqCEVlpMzclJeDiMs": { "title": "`httptest` for HTTP Tests", - "description": "The `httptest` package provides utilities for testing HTTP servers and clients without network connections. Includes `httptest.Server`, `ResponseRecorder`, and helpers for creating test requests. Essential for testing handlers, middleware, and HTTP services.", - "links": [] + "description": "The `httptest` package provides utilities for testing HTTP servers and clients without network connections. Includes `httptest.Server`, `ResponseRecorder`, and helpers for creating test requests. Essential for testing handlers, middleware, and HTTP services.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "httptest package", + "url": "https://pkg.go.dev/net/http/httptest", + "type": "article" + }, + { + "title": "Using httptest.Server in Go to Mock and Test External API Calls", + "url": "https://medium.com/@ullauri.byron/using-httptest-server-in-go-to-mock-and-test-external-api-calls-68ce444cf934", + "type": "article" + }, + { + "title": "Httptest Example", + "url": "https://golang.cafe/blog/golang-httptest-example.html", + "type": "article" + } + ] }, "t9xOuLBrAzEvv2-bOU2hF": { "title": "Benchmarks", - "description": "Benchmarks measure code performance by timing repeated executions. Functions start with `Benchmark` and use `*testing.B` parameter. Run with `go test -bench=.` to identify bottlenecks, compare implementations, and track performance changes over time.", - "links": [] + "description": "Benchmarks measure code performance by timing repeated executions. Functions start with `Benchmark` and use `*testing.B` parameter. Run with `go test -bench=.` to identify bottlenecks, compare implementations, and track performance changes over time.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Add a Test", + "url": "https://go.dev/doc/tutorial/add-a-test", + "type": "article" + }, + { + "title": "Benchmarking in Go: A Comprehensive Handbook", + "url": "https://betterstack.com/community/guides/scaling-go/golang-benchmarking/", + "type": "article" + }, + { + "title": "Benchmarking in Golang: Improving Function Performance", + "url": "https://blog.logrocket.com/benchmarking-golang-improve-function-performance/", + "type": "article" + } + ] }, "27lhNAdKwRrc2S2ha3QNG": { "title": "Coverage", - "description": "Test coverage measures code execution during testing using `go test -cover` and `-coverprofile`. Visualize with `go tool cover -html` to identify untested code paths. Helps maintain quality standards and guide testing efforts for more reliable applications.", - "links": [] + "description": "Test coverage measures code execution during testing using `go test -cover` and `-coverprofile`. Visualize with `go tool cover -html` to identify untested code paths. Helps maintain quality standards and guide testing efforts for more reliable applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Coverage Profiling", + "url": "https://go.dev/doc/build-cover", + "type": "article" + }, + { + "title": "Understanding Go Coverage: A Guide to Test Coverage in Go", + "url": "https://medium.com/@keployio/understanding-go-coverage-a-guide-to-test-coverage-in-go-0c6e5ac8ba81", + "type": "article" + } + ] }, "2fk1ewM42WnFlDejVETys": { "title": "Building CLIs", - "description": "Go excels at CLI development due to fast compilation, single binary distribution, and rich ecosystem. Use standard `flag` package or frameworks like Cobra, urfave/cli, Bubble Tea. Cross-compilation support for multiple platforms. Great for learning Go while building useful tools.", - "links": [] + "description": "Go excels at CLI development due to fast compilation, single binary distribution, and rich ecosystem. Use standard `flag` package or frameworks like Cobra, urfave/cli, Bubble Tea. Cross-compilation support for multiple platforms. Great for learning Go while building useful tools.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Command-line Interfaces (CLIs)", + "url": "https://go.dev/solutions/clis", + "type": "article" + }, + { + "title": "Building a Command Line Interface (CLI) tool in Golang", + "url": "https://medium.com/@mgm06bm/building-a-command-line-interface-cli-tool-in-golang-a-step-by-step-guide-44a7aad488e4", + "type": "article" + }, + { + "title": "Building a feature rich Command Line Interface (CLI) in GO", + "url": "https://blog.stackademic.com/building-a-feature-rich-command-line-interface-cli-in-go-42a127b090c8", + "type": "article" + } + ] }, "3frPZLeFXnHroY7_Uk5Dn": { "title": "Cobra", - "description": "Powerful library for modern CLI applications. Used by kubectl, Hugo, GitHub CLI. Provides nested subcommands, flags, intelligent suggestions, auto help generation, shell completion. Follows POSIX standards with clean API. Includes command generator for quick bootstrapping.", - "links": [] + "description": "Powerful library for modern CLI applications. Used by kubectl, Hugo, GitHub CLI. Provides nested subcommands, flags, intelligent suggestions, auto help generation, shell completion. Follows POSIX standards with clean API. Includes command generator for quick bootstrapping.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Cobra", + "url": "https://cobra.dev/", + "type": "article" + }, + { + "title": "How To Use the Cobra Package in Go", + "url": "https://www.digitalocean.com/community/tutorials/how-to-use-the-cobra-package-in-go", + "type": "article" + }, + { + "title": "Getting Started with Cobra", + "url": "https://dev.to/frasnym/getting-started-with-cobra-creating-multi-level-command-line-interfaces-in-golang-2j3k", + "type": "article" + } + ] }, "bmNLSk-XuK2EuLxPR1Sxh": { "title": "urfave/cli", - "description": "urfave/cli is a simple package for building command-line applications with intuitive API for commands, flags, and arguments. Features automatic help generation, bash completion, nested subcommands, and environment variable integration for lightweight CLI tools.", - "links": [] + "description": "urfave/cli is a simple package for building command-line applications with intuitive API for commands, flags, and arguments. Features automatic help generation, bash completion, nested subcommands, and environment variable integration for lightweight CLI tools.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "urfave/cli", + "url": "https://cli.urfave.org/", + "type": "article" + }, + { + "title": "Building Command Line Tools in Go with urfave/cli", + "url": "https://zetcode.com/golang/urfave-cli/", + "type": "article" + } + ] }, "x9hDkF73rmvbewrgRgyOv": { "title": "bubbletea", - "description": "Bubble Tea is a framework for building terminal UIs based on The Elm Architecture. Uses model-update-view pattern for interactive CLI applications with keyboard input, styling, and component composition. Excellent for sophisticated terminal tools and dashboards.", - "links": [] + "description": "Bubble Tea is a framework for building terminal UIs based on The Elm Architecture. Uses model-update-view pattern for interactive CLI applications with keyboard input, styling, and component composition. Excellent for sophisticated terminal tools and dashboards.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "charmbracelet/bubbletea", + "url": "https://github.com/charmbracelet/bubbletea", + "type": "opensource" + }, + { + "title": "Building UI of Golang CLI app with Bubble Tea", + "url": "https://medium.com/@originalrad50/building-ui-of-golang-cli-app-with-bubble-tea-68b61e25445e", + "type": "article" + }, + { + "title": "Intro to Bubble Tea in Go", + "url": "https://dev.to/andyhaskell/intro-to-bubble-tea-in-go-21lg", + "type": "article" + } + ] }, "CwGw3CDVLqErQGTwjzhmL": { "title": "Web Development", - "description": "Excellent for web development with built-in HTTP server support, efficient concurrency, rich ecosystem. Standard `net/http` package provides powerful tools for servers, requests/responses, RESTful APIs. Performance, simple deployment (single binary), and concurrency make it ideal for scalable web apps.", - "links": [] + "description": "Excellent for web development with built-in HTTP server support, efficient concurrency, rich ecosystem. Standard `net/http` package provides powerful tools for servers, requests/responses, RESTful APIs. Performance, simple deployment (single binary), and concurrency make it ideal for scalable web apps.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "http package", + "url": "https://pkg.go.dev/net/http", + "type": "article" + }, + { + "title": "net/http package in Go", + "url": "https://medium.com/@emonemrulhasan35/net-http-package-in-go-e178c67d87f1", + "type": "article" + }, + { + "title": "Mastering Concurrency in Golang", + "url": "https://thelinuxcode.com/mastering-concurrency-in-golang-a-deep-dive-into-the-waitgroup/", + "type": "article" + } + ] }, "NMLmbKjfMSqz-Iz2CooCl": { "title": "net/http (standard)", - "description": "Standard library package for HTTP client/server functionality. Provides HTTP server with routing, middleware support, client for making requests. Handles TLS, HTTP/2, cookies, multipart forms. Foundation for web development without external frameworks.", - "links": [] + "description": "Standard library package for HTTP client/server functionality. Provides HTTP server with routing, middleware support, client for making requests. Handles TLS, HTTP/2, cookies, multipart forms. Foundation for web development without external frameworks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "http package", + "url": "https://pkg.go.dev/net/http", + "type": "article" + }, + { + "title": "net/http package in Go", + "url": "https://medium.com/@emonemrulhasan35/net-http-package-in-go-e178c67d87f1", + "type": "article" + }, + { + "title": "How To Make an HTTP Server in Go", + "url": "https://www.digitalocean.com/community/tutorials/how-to-make-an-http-server-in-go", + "type": "article" + } + ] }, "xM1uUCXNrJwfTgi9E75KV": { "title": "gin", - "description": "Popular HTTP web framework emphasizing performance and productivity. Lightweight foundation for APIs/web services with minimal boilerplate. Fast routing, middleware, JSON validation, error management, built-in rendering. Clean API for RESTful services. Includes parameter binding, uploads, static files.", - "links": [] + "description": "Popular HTTP web framework emphasizing performance and productivity. Lightweight foundation for APIs/web services with minimal boilerplate. Fast routing, middleware, JSON validation, error management, built-in rendering. Clean API for RESTful services. Includes parameter binding, uploads, static files.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Gin Web Framework", + "url": "https://gin-gonic.com/", + "type": "article" + }, + { + "title": "Building a RESTful API in Go Using the Gin Framework", + "url": "https://medium.com/@godusan/building-a-restful-api-in-go-using-the-gin-framework-a-step-by-step-tutorial-part-1-2-70372ebfa988", + "type": "article" + }, + { + "title": "Developing a RESTful API with Go and Gin", + "url": "https://go.dev/doc/tutorial/web-service-gin", + "type": "article" + } + ] }, "1qhqEYf6wYf5sfXgTUnmi": { "title": "echo", - "description": "High-performance, minimalist web framework focusing on ease and speed. Provides routing, middleware, data binding, validation, rendering. Features automatic TLS, HTTP/2, WebSocket support. Built-in middleware for CORS, JWT, logging, compression. Popular for RESTful APIs and microservices.", - "links": [] + "description": "High-performance, minimalist web framework focusing on ease and speed. Provides routing, middleware, data binding, validation, rendering. Features automatic TLS, HTTP/2, WebSocket support. Built-in middleware for CORS, JWT, logging, compression. Popular for RESTful APIs and microservices.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "High Performance, Extensible, Minimalist Go Web framework", + "url": "https://echo.labstack.com/", + "type": "article" + }, + { + "title": "Echo Documentation", + "url": "https://echo.labstack.com/docs", + "type": "article" + }, + { + "title": "Best Practices for Structuring Scalable Golang APIs with Echo", + "url": "https://medium.com/@OTS415/structuring-golang-echo-apis-8d657de5dc7c", + "type": "article" + } + ] }, "5lJPsJwgy0_T7Xl6eQxuB": { "title": "fiber", - "description": "Fiber is an Express-inspired web framework built on fasthttp for exceptional performance. Provides familiar API with middleware, routing, templates, and WebSocket support. Popular for high-performance REST APIs and microservices requiring speed and simplicity.", - "links": [] + "description": "Fiber is an Express-inspired web framework built on fasthttp for exceptional performance. Provides familiar API with middleware, routing, templates, and WebSocket support. Popular for high-performance REST APIs and microservices requiring speed and simplicity.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "gofiber/fiber", + "url": "https://github.com/gofiber/fiber", + "type": "opensource" + }, + { + "title": "Fiber", + "url": "https://gofiber.io/", + "type": "article" + }, + { + "title": "Fiber Documentation", + "url": "https://docs.gofiber.io/", + "type": "article" + }, + { + "title": "Fiber Framework in Golang", + "url": "https://medium.com/@uzairahmed01/fiber-framework-in-golang-b5158499c9ad", + "type": "article" + }, + { + "title": "Go Fiber: Start Building RESTful APIs on Golang", + "url": "https://dev.to/percoguru/getting-started-with-apis-in-golang-feat-fiber-and-gorm-2n34", + "type": "article" + } + ] }, "p7yeYkbQKAjr2aA_eUno4": { "title": "beego", - "description": "Beego is a full-stack web framework providing MVC architecture, ORM, session management, caching, and admin interface generation. Follows convention over configuration with extensive tooling for rapid development of enterprise applications requiring comprehensive features.", - "links": [] + "description": "Beego is a full-stack web framework providing MVC architecture, ORM, session management, caching, and admin interface generation. Follows convention over configuration with extensive tooling for rapid development of enterprise applications requiring comprehensive features.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "beego/beego", + "url": "https://github.com/beego/beego", + "type": "opensource" + }, + { + "title": "Arrays", + "url": "https://go.dev/tour/moretypes/6", + "type": "article" + }, + { + "title": "Exploring Golang and Beego: A Beginner's Guide with Examples", + "url": "https://medium.com/@vijeshomen/exploring-golang-and-beego-a-beginners-guide-with-examples-part-1-79619f0db1ac", + "type": "article" + }, + { + "title": "beego package", + "url": "https://pkg.go.dev/github.com/beego/beego", + "type": "article" + } + ] }, "tBY6UB3gWZAxHPCFHoU_d": { "title": "gRPC & Protocol Buffers", - "description": "gRPC is a high-performance RPC framework using Protocol Buffers for serialization. Provides streaming, authentication, load balancing, and code generation from `.proto` files. Excellent for microservices with type safety, efficient binary format, and cross-language compatibility.", - "links": [] + "description": "gRPC is a high-performance RPC framework using Protocol Buffers for serialization. Provides streaming, authentication, load balancing, and code generation from `.proto` files. Excellent for microservices with type safety, efficient binary format, and cross-language compatibility.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "gRPC package", + "url": "https://pkg.go.dev/google.golang.org/grpc", + "type": "article" + }, + { + "title": "Building a GRPC Micro-Service in Go: A Comprehensive Guide", + "url": "https://medium.com/@leodahal4/building-a-grpc-micro-service-in-go-a-comprehensive-guide-82b6812ed253", + "type": "article" + }, + { + "title": "Understanding gRPC in Golang: A Comprehensive Guide", + "url": "https://dev.to/madhusgowda/understanding-grpc-in-golang-a-comprehensive-guide-with-examples-84c", + "type": "article" + } + ] }, "VcHHuIZ4lGzTxOoTwxA3e": { "title": "ORMs & DB Access", - "description": "Go offers multiple database access approaches: raw SQL with database/sql, ORMs like GORM/Ent, and query builders. Choose based on complexity needs - raw SQL for performance, ORMs for rapid development, query builders for balance. Consider connection pooling and migrations.", - "links": [] + "description": "Go offers multiple database access approaches: raw SQL with database/sql, ORMs like GORM/Ent, and query builders. Choose based on complexity needs - raw SQL for performance, ORMs for rapid development, query builders for balance. Consider connection pooling and migrations.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go ORMs Compared", + "url": "https://dev.to/encore/go-orms-compared-2c8g", + "type": "article" + }, + { + "title": "Master Data Management in Go: ORM & Libraries Guide", + "url": "https://medium.com/@romulo.gatto/master-data-management-in-go-orm-libraries-guide-cd30cd65cba0", + "type": "article" + } + ] }, "cOj6klfBzTQQ8G75umLQZ": { "title": "pgx", - "description": "pgx is a pure Go PostgreSQL driver providing both database/sql compatibility and native PostgreSQL features. Offers better performance than lib/pq, includes arrays, JSON support, connection pooling, and PostgreSQL-specific features like LISTEN/NOTIFY.", - "links": [] + "description": "pgx is a pure Go PostgreSQL driver providing both database/sql compatibility and native PostgreSQL features. Offers better performance than lib/pq, includes arrays, JSON support, connection pooling, and PostgreSQL-specific features like LISTEN/NOTIFY.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "pgx package", + "url": "https://pkg.go.dev/github.com/jackc/pgx", + "type": "article" + }, + { + "title": "Getting Started with PostgreSQL in Go using PGX", + "url": "https://betterstack.com/community/guides/scaling-go/postgresql-pgx-golang/", + "type": "article" + } + ] }, "fJdZIbAgOAB8nOEHQNsq6": { "title": "GORM", - "description": "Popular Object-Relational Mapping library for Go. Provides database abstraction with struct-based models, automatic migrations, associations, and query building. Supports multiple databases (MySQL, PostgreSQL, SQLite, SQL Server). Features hooks, transactions, and connection pooling.", - "links": [] + "description": "Popular Object-Relational Mapping library for Go. Provides database abstraction with struct-based models, automatic migrations, associations, and query building. Supports multiple databases (MySQL, PostgreSQL, SQLite, SQL Server). Features hooks, transactions, and connection pooling.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "GORM - The fantastic ORM library for Golang", + "url": "https://gorm.io/", + "type": "article" + }, + { + "title": "gorm package", + "url": "https://pkg.go.dev/gorm.io/gorm", + "type": "article" + }, + { + "title": "Getting Started on Golang Gorm", + "url": "https://medium.com/@itskenzylimon/getting-started-on-golang-gorm-af49381caf3f", + "type": "article" + } + ] }, "mGia5cJ7HFVXM0Fx5xhQE": { "title": "Logging", - "description": "Essential for monitoring, debugging, maintaining production applications. Standard `log` package and `slog` (Go 1.21+) for structured logging. Popular libraries: Zap (high-performance), Zerolog (zero-allocation), Logrus (feature-rich). Use appropriate log levels and structured messages.", - "links": [] + "description": "Essential for monitoring, debugging, maintaining production applications. Standard `log` package and `slog` (Go 1.21+) for structured logging. Popular libraries: Zap (high-performance), Zerolog (zero-allocation), Logrus (feature-rich). Use appropriate log levels and structured messages.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Structured Logging with slog", + "url": "https://go.dev/blog/slog", + "type": "article" + }, + { + "title": "Logging in Go with Slog: The Ultimate Guide", + "url": "https://betterstack.com/community/guides/logging/logging-in-go/", + "type": "article" + }, + { + "title": "Effective Logging in Go: Best Practices and Implementation", + "url": "https://dev.to/fazal_mansuri_/effective-logging-in-go-best-practices-and-implementation-guide-23hp", + "type": "article" + } + ] }, "TR7N68_evDMu3qWHbGJcz": { "title": "Zerolog", - "description": "Zerolog is a zero-allocation JSON logger focusing on performance and simplicity. Provides structured logging with fluent API, various log levels, and no memory allocations during operations, making it ideal for high-throughput production applications.", - "links": [] + "description": "Zerolog is a zero-allocation JSON logger focusing on performance and simplicity. Provides structured logging with fluent API, various log levels, and no memory allocations during operations, making it ideal for high-throughput production applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "zerolog package", + "url": "https://pkg.go.dev/github.com/rs/zerolog", + "type": "article" + }, + { + "title": "A Complete Guide to Logging in Go with Zerolog", + "url": "https://betterstack.com/community/guides/logging/zerolog/", + "type": "article" + }, + { + "title": "Zerolog Golang - Complete Guide to Logging", + "url": "https://signoz.io/guides/zerolog-golang/", + "type": "article" + } + ] }, "4D8QsZVAUB9vGbVFgRHt4": { "title": "Zap", - "description": "Zap is a high-performance structured logging library by Uber offering both structured and printf-style APIs. Features include JSON/console formats, configurable levels, sampling, and production-optimized performance through careful memory management.", - "links": [] + "description": "Zap is a high-performance structured logging library by Uber offering both structured and printf-style APIs. Features include JSON/console formats, configurable levels, sampling, and production-optimized performance through careful memory management.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "zap package - go.uber.org/zap", + "url": "https://pkg.go.dev/go.uber.org/zap", + "type": "article" + }, + { + "title": "A Comprehensive Guide to Zap Logging in Go", + "url": "https://betterstack.com/community/guides/logging/go/zap/", + "type": "article" + }, + { + "title": "Structured Logging in Golang with Zap", + "url": "https://codewithmukesh.com/blog/structured-logging-in-golang-with-zap/", + "type": "article" + } + ] }, "o2EYfm1WSd8Eq_ZcXYreo": { "title": "Realtime Communication", - "description": "Realtime communication in Go enables instant bidirectional updates using WebSockets, Server-Sent Events, and messaging patterns. Go's concurrency makes it ideal for handling multiple connections. Essential for chat apps, live dashboards, and interactive applications requiring immediate synchronization.", - "links": [] + "description": "Realtime communication in Go enables instant bidirectional updates using WebSockets, Server-Sent Events, and messaging patterns. Go's concurrency makes it ideal for handling multiple connections. Essential for chat apps, live dashboards, and interactive applications requiring immediate synchronization.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "http package", + "url": "https://pkg.go.dev/net/http", + "type": "article" + }, + { + "title": "Implementing WebSockets in Golang", + "url": "https://medium.com/wisemonks/implementing-websockets-in-golang-d3e8e219733b", + "type": "article" + } + ] }, "N0EG-7sU9lGFwgidXuPkV": { "title": "Melody", - "description": "Melody is a minimalist WebSocket framework for Go providing simple session management, message broadcasting, and connection handling. Features include rooms, automatic ping/pong, message limits, and clean integration with existing web frameworks for real-time apps.", - "links": [] + "description": "Melody is a minimalist WebSocket framework for Go providing simple session management, message broadcasting, and connection handling. Features include rooms, automatic ping/pong, message limits, and clean integration with existing web frameworks for real-time apps.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "olahol/melody: Minimalist websocket framework", + "url": "https://github.com/olahol/melody", + "type": "opensource" + }, + { + "title": "Melody Package", + "url": "https://pkg.go.dev/github.com/olahol/melody", + "type": "article" + }, + { + "title": "Build a Realtime Chat Server With Go and WebSockets", + "url": "https://gabrieltanner.org/blog/realtime-chat-go-websockets/", + "type": "article" + } + ] }, "LOl-7BtdmYrBS0PTtHI1I": { "title": "Centrifugo", - "description": "Centrifugo is a real-time messaging server providing WebSocket services for Go applications. It offers channels, presence info, message history, and Redis scalability. Supports WebSocket, Server-Sent Events, and HTTP streaming while handling complex real-time patterns.", - "links": [] + "description": "Centrifugo is a real-time messaging server providing WebSocket services for Go applications. It offers channels, presence info, message history, and Redis scalability. Supports WebSocket, Server-Sent Events, and HTTP streaming while handling complex real-time patterns.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "centrifugal/centrifuge", + "url": "https://github.com/centrifugal/centrifuge", + "type": "opensource" + }, + { + "title": "Centrifugo", + "url": "https://centrifugal.dev/", + "type": "article" + }, + { + "title": "Getting Started with Centrifugo", + "url": "https://centrifugal.dev/docs/getting-started/introduction", + "type": "article" + } + ] }, "rW4QPWIS2TWzFY0Ljny2N": { "title": "go run", - "description": "Compiles and executes Go programs in one step without creating executable files. Useful for testing, development, and running scripts. Takes Go source files as arguments. Convenient for quick execution during development without build artifacts.", - "links": [] + "description": "Compiles and executes Go programs in one step without creating executable files. Useful for testing, development, and running scripts. Takes Go source files as arguments. Convenient for quick execution during development without build artifacts.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go run", + "url": "https://go.dev/doc/tutorial/getting-started", + "type": "article" + }, + { + "title": "How to Build and Run Go Programs", + "url": "https://go-tutorial.com/build-and-run", + "type": "article" + }, + { + "title": "How To Build and Install Go Programs", + "url": "https://www.digitalocean.com/community/tutorials/how-to-build-and-install-go-programs", + "type": "article" + } + ] }, "LXqEJwGA_0cVUbF6DVwBG": { "title": "go build", - "description": "Compiles Go packages and dependencies into executable binaries. Supports cross-compilation for different OS/architectures via GOOS/GOARCH. Includes build constraints, custom flags, optimization levels. Produces statically linked binaries by default. Essential for deployment and distribution.", - "links": [] + "description": "Compiles Go packages and dependencies into executable binaries. Supports cross-compilation for different OS/architectures via GOOS/GOARCH. Includes build constraints, custom flags, optimization levels. Produces statically linked binaries by default. Essential for deployment and distribution.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Compile and Install the Application", + "url": "https://go.dev/doc/tutorial/compile-install", + "type": "article" + }, + { + "title": "How to Build and Run Go Programs", + "url": "https://go-tutorial.com/build-and-run", + "type": "article" + }, + { + "title": "How To Build and Install Go Programs", + "url": "https://www.digitalocean.com/community/tutorials/how-to-build-and-install-go-programs", + "type": "article" + } + ] }, "k35Ogbvr9yTdJPo4RV4tM": { "title": "go install", - "description": "Compiles and installs packages and dependencies. Creates executables in `$GOPATH/bin` for main packages. Use `go install package@version` to install specific versions of tools. Commonly used for installing CLI tools system-wide.", - "links": [] + "description": "Compiles and installs packages and dependencies. Creates executables in `$GOPATH/bin` for main packages. Use `go install package@version` to install specific versions of tools. Commonly used for installing CLI tools system-wide.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go install", + "url": "https://go.dev/doc/install", + "type": "article" + }, + { + "title": "Managing Go Installations", + "url": "https://go.dev/doc/manage-install", + "type": "article" + }, + { + "title": "Golang: How To Use the Go Install Command", + "url": "https://thenewstack.io/golang-how-to-use-the-go-install-command/", + "type": "article" + } + ] }, "CPFiclXXVQCsbooA0iCEy": { "title": "go fmt", - "description": "Automatically formats Go source code according to official style guidelines. Standardizes indentation, spacing, alignment for consistent code style. Opinionated and non-configurable, eliminating formatting debates. Essential for clean, readable, community-standard code.", - "links": [] + "description": "Automatically formats Go source code according to official style guidelines. Standardizes indentation, spacing, alignment for consistent code style. Opinionated and non-configurable, eliminating formatting debates. Essential for clean, readable, community-standard code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go fmt", + "url": "https://go.dev/blog/gofmt", + "type": "article" + }, + { + "title": "fmt package", + "url": "https://pkg.go.dev/fmt", + "type": "article" + }, + { + "title": "go fmt Command Examples", + "url": "https://www.thegeekdiary.com/go-fmt-command-examples/", + "type": "article" + } + ] }, "5hnaPrYSBzxEIxFeg5tCK": { "title": "go mod", - "description": "Command-line tool for module management. `go mod init` creates module, `go mod tidy` cleans dependencies, `go mod download` fetches modules. Manages go.mod and go.sum files. Essential commands for dependency management and version control.", - "links": [] + "description": "Command-line tool for module management. `go mod init` creates module, `go mod tidy` cleans dependencies, `go mod download` fetches modules. Manages go.mod and go.sum files. Essential commands for dependency management and version control.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go mod", + "url": "https://go.dev/doc/tutorial/create-module", + "type": "article" + }, + { + "title": "go mod commands", + "url": "https://blog.devtrovert.com/p/go-get-go-mod-tidy-commands", + "type": "article" + }, + { + "title": "What does go mod tidy do?", + "url": "https://golangbyexamples.com/go-mod-tidy/", + "type": "article" + } + ] }, "EskFmwCwOmZHcVzedPOJI": { "title": "go test", - "description": "Command for running tests in Go packages. Automatically finds and executes functions starting with `Test`. Supports benchmarks (`Benchmark`), examples (`Example`), and sub-tests. Includes coverage analysis, parallel execution, and various output formats. Essential for TDD and quality assurance.", - "links": [] + "description": "Command for running tests in Go packages. Automatically finds and executes functions starting with `Test`. Supports benchmarks (`Benchmark`), examples (`Example`), and sub-tests. Includes coverage analysis, parallel execution, and various output formats. Essential for TDD and quality assurance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go test", + "url": "https://go.dev/doc/tutorial/add-a-test", + "type": "article" + }, + { + "title": "How To Write Unit Tests in Go", + "url": "https://www.digitalocean.com/community/tutorials/how-to-write-unit-tests-in-go-using-go-test-and-the-testing-package", + "type": "article" + }, + { + "title": "Testing and Benchmarking in Go", + "url": "https://medium.com/hyperskill/testing-and-benchmarking-in-go-e33a54b413e", + "type": "article" + } + ] }, "bxXzXM0zUm1vux1DKOLyf": { "title": "go clean", - "description": "Removes object files and cached files from build process. Options include `-cache` for build cache and `-modcache` for module downloads. Useful for troubleshooting build issues, freeing disk space, and ensuring clean builds.", - "links": [] + "description": "Removes object files and cached files from build process. Options include `-cache` for build cache and `-modcache` for module downloads. Useful for troubleshooting build issues, freeing disk space, and ensuring clean builds.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Clean", + "url": "https://golang.google.cn/cmd/go/internal/clean/", + "type": "article" + }, + { + "title": "Make sure to clean your Go build cache", + "url": "https://www.adityathebe.com/how-to-clean-go-build-cache/", + "type": "article" + }, + { + "title": "Golang Clean Architecture", + "url": "https://www.youtube.com/watch?v=F5KLmp6aB5Q", + "type": "video" + } + ] }, "SoD0P5k4aSVRN96XxR5on": { "title": "go doc", - "description": "Prints documentation for Go packages, types, functions, and methods extracted from specially formatted comments. Use `go doc package` or `go doc package.Function` to view specific documentation. Essential for exploring APIs and verifying documentation formatting.", - "links": [] + "description": "Prints documentation for Go packages, types, functions, and methods extracted from specially formatted comments. Use `go doc package` or `go doc package.Function` to view specific documentation. Essential for exploring APIs and verifying documentation formatting.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go doc", + "url": "https://tip.golang.org/doc/comment", + "type": "article" + }, + { + "title": "go package", + "url": "https://pkg.go.dev/cmd/go", + "type": "article" + }, + { + "title": "Documenting Your Go Code with go doc", + "url": "https://go-cookbook.com/snippets/tools/go-doc", + "type": "article" + } + ] }, "LnhQJVsEaS_gSijCUqAMq": { "title": "go version", - "description": "Displays the currently installed Go version, target OS, and architecture. Essential for verifying installation, troubleshooting environment issues, and ensuring compatibility across different development environments and teams.", - "links": [] + "description": "Displays the currently installed Go version, target OS, and architecture. Essential for verifying installation, troubleshooting environment issues, and ensuring compatibility across different development environments and teams.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Go Versions", + "url": "https://go.dev/dl/", + "type": "article" + }, + { + "title": "Updating Go Version", + "url": "https://www.golang101.com/questions/how-to-update-golang-version/", + "type": "article" + }, + { + "title": "How to Check My Golang Version (Win, MacOS, Linux)", + "url": "https://blog.finxter.com/how-to-check-my-golang-version-win-macos-linux/", + "type": "article" + } + ] }, "TstTkc_-2RZMOqtSIklEM": { "title": "go generate", - "description": "The `go generate` command executes commands specified in `//go:generate` directives to generate Go source code. Used for code generation from templates, string methods, embedded resources, and running tools like protobuf compilers for build automation.", - "links": [] + "description": "The `go generate` command executes commands specified in `//go:generate` directives to generate Go source code. Used for code generation from templates, string methods, embedded resources, and running tools like protobuf compilers for build automation.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go generate", + "url": "https://go.dev/blog/generate", + "type": "article" + }, + { + "title": "How to Use //go:generate", + "url": "https://blog.carlana.net/post/2016-11-27-how-to-use-go-generate/", + "type": "article" + }, + { + "title": "Metaprogramming with Go", + "url": "https://dev.to/hlubek/metaprogramming-with-go-or-how-to-build-code-generators-that-parse-go-code-2k3j", + "type": "article" + } + ] }, "Jxt4HD2iA6lRXNRJIVCLs": { "title": "Build Tags", - "description": "Build tags control file inclusion using `//go:build` directives based on conditions like OS, architecture, or custom tags. Enable conditional compilation for platform-specific code, feature flags, and environment-specific builds without runtime overhead.", - "links": [] + "description": "Build tags control file inclusion using `//go:build` directives based on conditions like OS, architecture, or custom tags. Enable conditional compilation for platform-specific code, feature flags, and environment-specific builds without runtime overhead.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Build Package", + "url": "https://pkg.go.dev/go/build", + "type": "article" + }, + { + "title": "Advanced Go Build Techniques", + "url": "https://dev.to/jacktt/go-build-in-advance-4o8n", + "type": "article" + }, + { + "title": "Customizing Go Binaries with Build Tags", + "url": "https://www.digitalocean.com/community/tutorials/customizing-go-binaries-with-build-tags", + "type": "article" + } + ] }, "qoQ6_5MgTu3ur1mkEgqG5": { "title": "go vet", - "description": "Built-in tool analyzing Go source code for suspicious constructs likely to be bugs. Checks for unreachable code, incorrect printf formats, struct tag mistakes, and potential nil pointer dereferences. Automatically run by `go test`.", - "links": [] + "description": "Built-in tool analyzing Go source code for suspicious constructs likely to be bugs. Checks for unreachable code, incorrect printf formats, struct tag mistakes, and potential nil pointer dereferences. Automatically run by `go test`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go vet", + "url": "https://pkg.go.dev/cmd/vet", + "type": "article" + }, + { + "title": "Go: Vet Command Is More Powerful Than You Think", + "url": "https://medium.com/a-journey-with-go/go-vet-command-is-more-powerful-than-you-think-563e9fdec2f5", + "type": "article" + }, + { + "title": "Using go vet for Code Analysis", + "url": "https://medium.com/a-journey-with-go/go-vet-command-is-more-powerful-than-you-think-563e9fdec2f5", + "type": "article" + } + ] }, "6RpfXYHnOGmM6pZ6ZBb29": { "title": "goimports", - "description": "Tool automatically managing Go import statements by adding missing imports and removing unused ones while formatting code. More convenient than manual import management, integrates with editors for automatic execution on save.", - "links": [] + "description": "Tool automatically managing Go import statements by adding missing imports and removing unused ones while formatting code. More convenient than manual import management, integrates with editors for automatic execution on save.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "go import", + "url": "https://go.dev/tour/basics/2", + "type": "article" + }, + { + "title": "An introduction to Packages, Imports and Modules in Go", + "url": "https://www.alexedwards.net/blog/an-introduction-to-packages-imports-and-modules", + "type": "article" + }, + { + "title": "Unraveling Packages and Imports in Golang", + "url": "https://medium.com/hprog99/unraveling-packages-and-imports-in-golang-a-comprehensive-guide-8f0ea320562a", + "type": "article" + } + ] }, "ksimJz7uvSh80ZIekSn_-": { "title": "revive", - "description": "Fast, configurable Go linter providing rich formatting and many rules for code analysis. Drop-in replacement for golint with better performance, configurable rules, and various output formats. Helps maintain consistent code quality across projects.", - "links": [] + "description": "Fast, configurable Go linter providing rich formatting and many rules for code analysis. Drop-in replacement for golint with better performance, configurable rules, and various output formats. Helps maintain consistent code quality across projects.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "mgechev/revive", + "url": "https://github.com/mgechev/revive", + "type": "opensource" + }, + { + "title": "revive - fast & configurable linter for Go", + "url": "https://revive.run/docs", + "type": "article" + }, + { + "title": "Level Up Your Go Style with revive", + "url": "https://medium.com/@caring_smitten_gerbil_914/%EF%B8%8F-level-up-your-go-style-with-revive-the-fast-configurable-community-friendly-linter-78dacbe74191", + "type": "article" + } + ] }, "954ffF8CmXYX-L36Lfl44": { "title": "staticcheck", - "description": "State-of-the-art Go linter catching bugs, performance issues, and style problems through static analysis. Provides more comprehensive checking than go vet with very few false positives. Detects unused code, incorrect API usage, and subtle bugs.", - "links": [] + "description": "State-of-the-art Go linter catching bugs, performance issues, and style problems through static analysis. Provides more comprehensive checking than go vet with very few false positives. Detects unused code, incorrect API usage, and subtle bugs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "dominikh/go-tools: Staticcheck", + "url": "https://github.com/dominikh/go-tools", + "type": "opensource" + }, + { + "title": "Staticcheck", + "url": "https://staticcheck.dev/docs/", + "type": "article" + } + ] }, "hgiNcGh3ggf8dBJ8C0HCL": { "title": "golangci-lint", - "description": "Fast, parallel runner for multiple Go linters including staticcheck, go vet, and revive. Provides unified configuration, output formatting, and performance optimization. Streamlines code quality workflows through a single comprehensive tool.", - "links": [] + "description": "Fast, parallel runner for multiple Go linters including staticcheck, go vet, and revive. Provides unified configuration, output formatting, and performance optimization. Streamlines code quality workflows through a single comprehensive tool.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "golangci/golangci-lint", + "url": "https://github.com/golangci/golangci-lint", + "type": "opensource" + }, + { + "title": "golangci-lint", + "url": "https://golangci-lint.run/", + "type": "article" + }, + { + "title": "golangci-linters", + "url": "https://golangci-lint.run/usage/linters/", + "type": "article" + } + ] }, "K__satcG2ETNRFBpPqrLw": { "title": "govulncheck", - "description": "Go's official vulnerability scanner checking code and dependencies for known security vulnerabilities. Reports packages with vulnerabilities from Go database, provides severity info and remediation advice. Essential for maintaining secure applications.", - "links": [] + "description": "Go's official vulnerability scanner checking code and dependencies for known security vulnerabilities. Reports packages with vulnerabilities from Go database, provides severity info and remediation advice. Essential for maintaining secure applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "govulncheck", + "url": "https://go.dev/doc/tutorial/govulncheck", + "type": "article" + }, + { + "title": "Using govulncheck to Detect Vulnerable Dependencies in Go", + "url": "https://medium.com/@caring_smitten_gerbil_914/%EF%B8%8F-using-govulncheck-to-detect-vulnerable-dependencies-in-go-627a634f1edd", + "type": "article" + } + ] }, "Blz9cpgKhuqtY75oUQw6I": { "title": "pprof", - "description": "Built-in profiling tool for analyzing program performance. Profiles CPU usage, memory allocation, goroutines, blocking operations. Import `net/http/pprof` for web interface or use `go tool pprof` for analysis. Essential for performance optimization and bottleneck identification.", - "links": [] + "description": "Built-in profiling tool for analyzing program performance. Profiles CPU usage, memory allocation, goroutines, blocking operations. Import `net/http/pprof` for web interface or use `go tool pprof` for analysis. Essential for performance optimization and bottleneck identification.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "pprof package", + "url": "https://pkg.go.dev/runtime/pprof", + "type": "article" + }, + { + "title": "Go Profiling with pprof: A Step-by-Step Guide", + "url": "https://medium.com/@jhathnagoda/go-profiling-with-pprof-a-step-by-step-guide-a62323915cb0", + "type": "article" + } + ] }, "RE2jfECHkWvy3ldDZL938": { "title": "trace", - "description": "The Go trace tool captures execution traces showing goroutine execution, system calls, GC, and scheduling. Generate traces with `runtime/trace` package, analyze with `go tool trace`. Provides web interface for diagnosing concurrency issues and performance bottlenecks.", - "links": [] + "description": "The Go trace tool captures execution traces showing goroutine execution, system calls, GC, and scheduling. Generate traces with `runtime/trace` package, analyze with `go tool trace`. Provides web interface for diagnosing concurrency issues and performance bottlenecks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Execution Traces", + "url": "https://go.dev/blog/execution-traces-2024", + "type": "article" + }, + { + "title": "Introduction to Tracing in Go with Jaeger & OpenTelemetry", + "url": "https://medium.com/@nairouasalaton/introduction-to-tracing-in-go-with-jaeger-opentelemetry-71955c2afa39", + "type": "article" + }, + { + "title": "Go: Discovery of the Trace Package", + "url": "https://medium.com/a-journey-with-go/go-discovery-of-the-trace-package-e5a821743c3c", + "type": "article" + } + ] }, "7aTYeCd915F3UHqb6j0Az": { "title": "Race Detector", - "description": "Runtime tool detecting data races in concurrent programs using the `-race` flag. Tracks memory accesses and reports conflicts with detailed information including stack traces. Essential for finding concurrency bugs during development and testing.", - "links": [] + "description": "Runtime tool detecting data races in concurrent programs using the `-race` flag. Tracks memory accesses and reports conflicts with detailed information including stack traces. Essential for finding concurrency bugs during development and testing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Race Detection", + "url": "https://go.dev/doc/articles/race_detector", + "type": "article" + }, + { + "title": "Go: Race Detector with ThreadSanitizer", + "url": "https://medium.com/a-journey-with-go/go-race-detector-with-threadsanitizer-8e497f9e42db", + "type": "article" + }, + { + "title": "Data Race Detection and Data Race Patterns in Golang", + "url": "https://www.sobyte.net/post/2022-06/go-data-race/", + "type": "article" + } + ] }, "mvcWcecHA_jyQY1txFgL_": { "title": "Cross-compilation", - "description": "Build executables for different OS and architectures using `GOOS` and `GOARCH` environment variables. Example: `GOOS=linux GOARCH=amd64 go build` creates Linux binaries. Enables multi-platform development without separate build environments.", - "links": [] + "description": "Build executables for different OS and architectures using `GOOS` and `GOARCH` environment variables. Example: `GOOS=linux GOARCH=amd64 go build` creates Linux binaries. Enables multi-platform development without separate build environments.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "GccgoCrossCompilation", + "url": "https://go.dev/wiki/GccgoCrossCompilation", + "type": "article" + }, + { + "title": "Cross-compiling made easy with Golang", + "url": "https://medium.com/@keployio/understanding-go-coverage-a-guide-to-test-coverage-in-go-0c6e5ac8ba81", + "type": "article" + } + ] }, "zCUmPIGVslLfECqfUgAr2": { "title": "Building Executables", - "description": "The `go build` command compiles source code into standalone native executables with static linking. Creates self-contained binaries including all dependencies, requiring no Go installation on target systems. Control builds with various optimization flags.", - "links": [] + "description": "The `go build` command compiles source code into standalone native executables with static linking. Creates self-contained binaries including all dependencies, requiring no Go installation on target systems. Control builds with various optimization flags.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Build Package", + "url": "https://pkg.go.dev/go/build", + "type": "article" + }, + { + "title": "Compile and Install Application", + "url": "https://go.dev/doc/tutorial/compile-install", + "type": "article" + }, + { + "title": "Advanced Go Build Techniques", + "url": "https://dev.to/jacktt/go-build-in-advance-4o8n", + "type": "article" + }, + { + "title": "Customizing Go Binaries with Build Tags", + "url": "https://www.digitalocean.com/community/tutorials/customizing-go-binaries-with-build-tags", + "type": "article" + }, + { + "title": "How To Build and Install Go Programs", + "url": "https://www.digitalocean.com/community/tutorials/how-to-build-and-install-go-programs", + "type": "article" + } + ] }, "_2JpTdzmXxszFCauJONCi": { "title": "Memory Mgmt. in Depth", - "description": "Deep memory management involves understanding garbage collection, escape analysis, allocation patterns, and optimization techniques. Covers stack vs heap allocation, memory pooling, reducing allocations, and GC interaction for high-performance applications.", - "links": [] + "description": "Deep memory management involves understanding garbage collection, escape analysis, allocation patterns, and optimization techniques. Covers stack vs heap allocation, memory pooling, reducing allocations, and GC interaction for high-performance applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "The Go Memory Model", + "url": "https://go.dev/ref/mem", + "type": "article" + }, + { + "title": "A Deep Dive into Golang Memory", + "url": "https://mtardy.com/posts/memory-golang/", + "type": "article" + }, + { + "title": "How Go Manages Memory and Why It's So Efficient", + "url": "https://medium.com/@siddharthnarayan/how-go-manages-memory-and-why-its-so-efficient-68c13133ba1c", + "type": "article" + } + ] }, "ixoXVtRlrvTittqQq-Bgo": { "title": "Escape Analysis", - "description": "Compile-time optimization determining whether variables are allocated on stack (fast) or heap (GC required). Variables that \"escape\" their scope need heap allocation. Use `go build -gcflags=\"-m\"` to view decisions. Understanding helps minimize heap allocations and reduce GC pressure.", - "links": [] + "description": "Compile-time optimization determining whether variables are allocated on stack (fast) or heap (GC required). Variables that \"escape\" their scope need heap allocation. Use `go build -gcflags=\"-m\"` to view decisions. Understanding helps minimize heap allocations and reduce GC pressure.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Escape Analysis in Go: Stack vs Heap Allocation Explained", + "url": "https://dev.to/abstractmusa/escape-analysis-in-go-stack-vs-heap-allocation-explained-506a", + "type": "article" + }, + { + "title": "Escape Analysis in Golang", + "url": "https://medium.com/@trinad536/escape-analysis-in-golang-fc81b78f3550", + "type": "article" + } + ] }, "GO50AoBOjO-EaK3s36jSS": { "title": "Reflection", - "description": "Reflection allows runtime inspection and manipulation of types and values using the `reflect` package. Enables dynamic method calls and type examination but has performance overhead. Used in JSON marshaling, ORMs, and frameworks.", - "links": [] + "description": "Reflection allows runtime inspection and manipulation of types and values using the `reflect` package. Enables dynamic method calls and type examination but has performance overhead. Used in JSON marshaling, ORMs, and frameworks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "reflect package", + "url": "https://pkg.go.dev/reflect", + "type": "article" + }, + { + "title": "The Laws of Reflection", + "url": "https://go.dev/blog/laws-of-reflection", + "type": "article" + }, + { + "title": "Reflection in Go: Use cases and tutorial", + "url": "https://blog.logrocket.com/reflection-go-use-cases-tutorial/", + "type": "article" + } + ] }, "tM-AAWqMJsYZ1i6DCfBeD": { "title": "Unsafe Package", - "description": "The `unsafe` package bypasses Go's type and memory safety for direct memory manipulation and pointer arithmetic. Powerful but dangerous - can cause crashes and vulnerabilities. Used for systems programming and performance-critical code. Use with extreme caution.", - "links": [] + "description": "The `unsafe` package bypasses Go's type and memory safety for direct memory manipulation and pointer arithmetic. Powerful but dangerous - can cause crashes and vulnerabilities. Used for systems programming and performance-critical code. Use with extreme caution.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "unsafe package", + "url": "https://pkg.go.dev/unsafe", + "type": "article" + }, + { + "title": "Go: What is the Unsafe Package?", + "url": "https://medium.com/a-journey-with-go/go-what-is-the-unsafe-package-d2443da36350", + "type": "article" + }, + { + "title": "Unsafe Package Usage in Go", + "url": "https://go-cookbook.com/snippets/standard-library-packages/unsafe-package", + "type": "article" + } + ] }, "zmBYvecc5zSoLCinH68gc": { "title": "Build Constraints & Tags", - "description": "Special comments controlling which files are included when building. Use `//go:build` directive for platform-specific code, environment builds, or feature toggles. Common for different OS/architectures or debug vs production builds. Essential for portable Go applications.", - "links": [] + "description": "Special comments controlling which files are included when building. Use `//go:build` directive for platform-specific code, environment builds, or feature toggles. Common for different OS/architectures or debug vs production builds. Essential for portable Go applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Build Package", + "url": "https://pkg.go.dev/go/build", + "type": "article" + }, + { + "title": "Advanced Go Build Techniques", + "url": "https://dev.to/jacktt/go-build-in-advance-4o8n", + "type": "article" + }, + { + "title": "Customizing Go Binaries with Build Tags", + "url": "https://www.digitalocean.com/community/tutorials/customizing-go-binaries-with-build-tags", + "type": "article" + } + ] }, "mxbs96wFJ5XGDoETA0fU_": { "title": "CGO Basics", - "description": "CGO allows Go programs to call C code and vice versa using special comments. Enables C library integration but disables cross-compilation, reduces performance, and complicates deployment. Useful for legacy integration but pure Go is preferred.", - "links": [] + "description": "CGO allows Go programs to call C code and vice versa using special comments. Enables C library integration but disables cross-compilation, reduces performance, and complicates deployment. Useful for legacy integration but pure Go is preferred.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "CGO", + "url": "https://go.dev/wiki/cgo", + "type": "article" + }, + { + "title": "Understand How to use C libraries in Go with CGO", + "url": "https://dev.to/metal3d/understand-how-to-use-c-libraries-in-go-with-cgo-3dbn", + "type": "article" + }, + { + "title": "Calling C Functions from Go: A Quick Guide", + "url": "https://www.codingexplorations.com/blog/calling-c-functions-from-go-a-quick-guide", + "type": "article" + } + ] }, "xsjUeyxweN2GbcjknDjT8": { "title": "Compiler & Linker Flags", - "description": "Build flags control compilation and linking. Common flags include `-ldflags` for linker options, `-gcflags` for compiler settings, `-tags` for build tags, and `-race` for race detection. Help optimize builds, reduce binary size, and embed build information.", - "links": [] + "description": "Build flags control compilation and linking. Common flags include `-ldflags` for linker options, `-gcflags` for compiler settings, `-tags` for build tags, and `-race` for race detection. Help optimize builds, reduce binary size, and embed build information.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Flag Package", + "url": "https://pkg.go.dev/flag", + "type": "article" + }, + { + "title": "Leveraging Compiler Optimization Flags", + "url": "https://goperf.dev/01-common-patterns/comp-flags/o", + "type": "article" + }, + { + "title": "Compiler Optimization Flags", + "url": "https://diginode.in/go/compiler-optimization-flags/", + "type": "article" + } + ] }, "NlkrCAdUCJ7kU9meQJM5_": { "title": "Plugins & Dynamic Loading", - "description": "Go's plugin system allows loading shared libraries (.so files) at runtime using the `plugin` package. Built with `go build -buildmode=plugin`. Enables modular architectures but has limitations: Unix-only, version compatibility issues, and complexity.", - "links": [] + "description": "Go's plugin system allows loading shared libraries (.so files) at runtime using the `plugin` package. Built with `go build -buildmode=plugin`. Enables modular architectures but has limitations: Unix-only, version compatibility issues, and complexity.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "plugin package", + "url": "https://pkg.go.dev/plugin", + "type": "article" + }, + { + "title": "Plugins with Go How to use Go's standard", + "url": "https://medium.com/profusion-engineering/plugins-with-go-7ea1e7a280d3", + "type": "article" + }, + { + "title": "Plugin in Golang", + "url": "https://dev.to/jacktt/plugin-in-golang-4m67", + "type": "article" + } + ] } } \ No newline at end of file diff --git a/public/roadmap-content/java.json b/public/roadmap-content/java.json index c849d0ed5..b9933a53f 100644 --- a/public/roadmap-content/java.json +++ b/public/roadmap-content/java.json @@ -305,11 +305,6 @@ "title": "Method Chaining", "description": "Method chaining is a programming technique where multiple method calls are made sequentially on the same object, one after another, in a single statement. Each method in the chain returns an object, allowing the next method to be called on that returned object. This approach enhances code readability and conciseness by reducing the need for temporary variables and intermediate steps.\n\nVisit the following resources to learn more:", "links": [ - { - "title": "Java Method Chaining - Java Explained", - "url": "https://bito.ai/resources/java-method-chaining-java-explained", - "type": "article" - }, { "title": "How to achieve method chaining in Java", "url": "https://stackoverflow.com/questions/21180269/how-to-achieve-method-chaining-in-java", diff --git a/public/roadmap-content/qa.json b/public/roadmap-content/qa.json index e050ed9e8..f002770f1 100644 --- a/public/roadmap-content/qa.json +++ b/public/roadmap-content/qa.json @@ -1250,11 +1250,6 @@ "title": "Backend Automation", "description": "Backend Testing is a testing method that checks the server side or database of web applications or software. Backend testing aims to test the application layer or database layer to ensure that the web application or software is free from database defects like deadlock, data corruption, or data loss.\n\nVisit the following resources to learn more:", "links": [ - { - "title": "What is Backend Testing?", - "url": "https://testinggenez.com/what-is-backend-testing-and-types/", - "type": "article" - }, { "title": "Backend Testing Tutorial", "url": "https://www.guru99.com/what-is-backend-testing.html", diff --git a/public/roadmap-content/software-design-architecture.json b/public/roadmap-content/software-design-architecture.json index 36a88e7ae..49d6877e7 100644 --- a/public/roadmap-content/software-design-architecture.json +++ b/public/roadmap-content/software-design-architecture.json @@ -276,19 +276,8 @@ }, "9naCfoHF1LW1OEsVZGi8v": { "title": "Keep it simple and refactor often", - "description": "Keeping framework code distant refers to separating the application's code from the framework's code. By doing so, it makes it easier to maintain, test, and upgrade the application's codebase and the framework independently.\n\nHere are some ways to keep framework code distant in system architecture:\n\n1. Use an abstraction layer to separate the application code from the framework code. This allows the application code to be written without the need to know the specifics of the framework.\n2. Use dependency injection to decouple the application code from the framework code. This allows the application code to use the framework's functionality without having to instantiate the framework objects directly.\n3. Avoid using framework-specific libraries or classes in the application code. This makes it easier to switch to a different framework in the future if needed.\n4. Use a standard interface for the application code to interact with the framework. This allows the application code to be written without the need to know the specifics of the framework.\n5. Keep the application and the framework code in separate projects and/or repositories.\n\nBy following these best practices, the system architecture will be more maintainable, testable, and less error-prone, and it will be easier to upgrade or switch the framework if needed.\n\nLearn more from the following links:", - "links": [ - { - "title": "Clean architecture", - "url": "https://pusher.com/tutorials/clean-architecture-introduction/", - "type": "article" - }, - { - "title": "Explore top posts about General Programming", - "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", - "type": "article" - } - ] + "description": "", + "links": [] }, "TDhTYdEyBuOnDKcQJzTAk": { "title": "Programming Paradigms", diff --git a/public/roadmap-content/system-design.json b/public/roadmap-content/system-design.json index d34121905..ff0f9050e 100644 --- a/public/roadmap-content/system-design.json +++ b/public/roadmap-content/system-design.json @@ -1321,16 +1321,10 @@ } ] }, - "LncTxPg-wx8loy55r5NmV": { - "title": "Queue-Based Load Leveling", - "description": "Use a queue that acts as a buffer between a task and a service it invokes in order to smooth intermittent heavy loads that can cause the service to fail or the task to time out. This can help to minimize the impact of peaks in demand on availability and responsiveness for both the task and the service.\n\nTo learn more visit the following links:", - "links": [ - { - "title": "Queue-Based Load Leveling pattern", - "url": "https://learn.microsoft.com/en-us/azure/architecture/patterns/queue-based-load-leveling", - "type": "article" - } - ] + "queu-based-load-leveling@LncTxPg-wx8loy55r5NmV.md": { + "title": "Queu-based Load Leveling", + "description": "", + "links": [] }, "2ryzJhRDTo98gGgn9mAxR": { "title": "Publisher/Subscriber", diff --git a/public/roadmap-content/technical-writer.json b/public/roadmap-content/technical-writer.json index d0c60aef5..9eb3159aa 100644 --- a/public/roadmap-content/technical-writer.json +++ b/public/roadmap-content/technical-writer.json @@ -51,9 +51,9 @@ } ] }, - "j69erqfosSZMDlmKcnnn0": { - "title": "Role of Technical Writers in Organizations", - "description": "The role of a **Technical Writer** is primarily to translate complex technical information into simpler language that is easy to understand for a non-technical audience. They design, write, edit, and rewrite technical pieces like operating instructions, FAQs, installation guides, and more. Apart from this, they also gather and disseminate technical information among customers, designers, and manufacturers. Essentially, their job involves communicating technical terminologies and a clear understanding of complex information to those who need it in an easy-to-understand format.", + "role-of-technical-writers-inorganizations@j69erqfosSZMDlmKcnnn0.md": { + "title": "Role of Technical Writers inOrganizations", + "description": "", "links": [] }, "cNeT1dJDfgn0ndPzSxhSL": { diff --git a/public/roadmap-content/vue.json b/public/roadmap-content/vue.json index 539104a94..aa442cf52 100644 --- a/public/roadmap-content/vue.json +++ b/public/roadmap-content/vue.json @@ -25,8 +25,8 @@ "type": "opensource" }, { - "title": "Creating a Vue Project", - "url": "https://cli.vuejs.org/guide/creating-a-project.html", + "title": "Quick Start | Vue.js", + "url": "https://vuejs.org/guide/quick-start.html", "type": "article" }, {