# Go Development

Published articles for Go Development.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Ep. 3: Mastering Kubernetes: Setting Up Environments with Kind

DevFeed: [Ep. 3: Mastering Kubernetes: Setting Up Environments with Kind](<https://devfeed.tech/articles/ep-3-mastering-kubernetes-setting-up-environments-with-kind-22237.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/05/mastering-kubernetes-setting-up-environments-with-kind-ep-3.html>)

Published: 2024-05-28T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [Deployment](<https://devfeed.tech/topics/deployment.md>), [networking](<https://devfeed.tech/topics/networking.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Development](<https://devfeed.tech/topics/development.md>)

Tags: [cli](<https://devfeed.tech/tags/cli.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [code-modularity](<https://devfeed.tech/tags/code-modularity.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [docker](<https://devfeed.tech/tags/docker.md>), [go](<https://devfeed.tech/tags/go.md>), [go-development](<https://devfeed.tech/tags/go-development.md>), [go-projects](<https://devfeed.tech/tags/go-projects.md>), [guides](<https://devfeed.tech/tags/guides.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [memory](<https://devfeed.tech/tags/memory.md>), [networking](<https://devfeed.tech/tags/networking.md>), [package-architecture](<https://devfeed.tech/tags/package-architecture.md>), [software-design](<https://devfeed.tech/tags/software-design.md>), [troubleshooting](<https://devfeed.tech/tags/troubleshooting.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

This video tutorial explains how to set up and manage a Kubernetes development environment using kind, Kubernetes inside Docker. It covers clusters, nodes, pods, resource allocation, networking, asynchronous operations, deployment monitoring, and troubleshooting for Go applications.

### Source excerpt

Introduction: In this installment of the Ultimate Software Design series, Bill guides us through setting up a Kubernetes environment using Kubernetes inside Docker (kind). He breaks down the structure of Kubernetes and offers insights into effective cluster management, ensuring a robust and efficient development environment. Effective Cluster Management: Learn the basics of setting up and managing a Kubernetes cluster, essential for maintaining scalable and resilient Go applications. Pod and Node Configuration: Understand how to configure pods and nodes to optimize compute resources and ensure seamless application deployment.

## Ep. 2: Elevating Software Design in Go: Package Architecture in Modern Development

DevFeed: [Ep. 2: Elevating Software Design in Go: Package Architecture in Modern Development](<https://devfeed.tech/articles/ep-2-elevating-software-design-in-go-package-architecture-in-modern-development-22235.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/05/elevating-software-design-in-go-package-architecture-in-modern-development-ep-2.html>)

Published: 2024-05-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [api-design](<https://devfeed.tech/tags/api-design.md>), [code-modularity](<https://devfeed.tech/tags/code-modularity.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [go](<https://devfeed.tech/tags/go.md>), [go-development](<https://devfeed.tech/tags/go-development.md>), [go-projects](<https://devfeed.tech/tags/go-projects.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [modularity](<https://devfeed.tech/tags/modularity.md>), [package-architecture](<https://devfeed.tech/tags/package-architecture.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [software-design](<https://devfeed.tech/tags/software-design.md>)

### AI overview

This video episode explains package architecture in Go. It emphasizes clear boundaries between components, focused package functionality, avoiding generic packages such as "Utils" or "Common," and the role of robust type systems in maintainable software.

### Source excerpt

Introduction: In this insightful episode, Bill dives deep into the realm of package design, shedding light on its crucial role in software development. Here are three key takeaways for Go developers: Code Modularity: Learn how Go's packaging system creates essential firewalls between program components, enhancing maintainability. Focused Functionality: Discover the importance of designing packages that provide specific functionality, fostering code clarity. Avoiding Pitfalls: Bill warns against common package design mistakes like centralized "common" packages, promoting a layered approach to maintainable code.

## Ep. 1: Mastering Software Design: Architectural Layers and Coding Modes

DevFeed: [Ep. 1: Mastering Software Design: Architectural Layers and Coding Modes](<https://devfeed.tech/articles/ep-1-mastering-software-design-architectural-layers-and-coding-modes-22238.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/05/mastering-software-design-architectural-layers-and-coding-modes-ep-1.html>)

Published: 2024-05-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Software Engineering](<https://devfeed.tech/topics/software-engineering.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [coding-modes](<https://devfeed.tech/tags/coding-modes.md>), [go](<https://devfeed.tech/tags/go.md>), [go-development](<https://devfeed.tech/tags/go-development.md>), [go-projects](<https://devfeed.tech/tags/go-projects.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [readability](<https://devfeed.tech/tags/readability.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [software-design](<https://devfeed.tech/tags/software-design.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [ultimate-software-design-series](<https://devfeed.tech/tags/ultimate-software-design-series.md>), [writing-code](<https://devfeed.tech/tags/writing-code.md>)

### AI overview

This episode of the Ultimate Software Design series explains how to create clear, precise, robust, and maintainable code in Go. It covers readability, semantic precision in components, functions, and variables, the distinction between programming and engineering modes, and systematic refactoring focused on precision, testability, and readability.

### Source excerpt

Introduction: Embark on a journey into the heart of software design with the Ultimate Software Design series, where Bill navigates through the intricacies of crafting robust and maintainable code in Go. Understand the importance of prioritizing clarity over brevity in code, fostering better understanding and collaboration among Go developers. Learn how to ensure precision in every aspect of Go development, emphasizing the necessity for precise semantic meanings in components, functions, and variables.

## Using Go workspaces in Kubernetes

DevFeed: [Using Go workspaces in Kubernetes](<https://devfeed.tech/articles/using-go-workspaces-in-kubernetes-17576.md>)

Original publisher: [Read original article](<https://www.kubernetes.dev/blog/2024/03/19/go-workspaces-in-kubernetes/>)

Author: The Kubernetes Authors

Published: 2024-03-19T16:30:00Z

Content type: tutorial

Language: en

Sources: [Kubernetes Contributors Blog](<https://devfeed.tech/sources/kubernetes-contributors-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Development](<https://devfeed.tech/topics/development.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [development](<https://devfeed.tech/tags/development.md>), [go](<https://devfeed.tech/tags/go.md>), [go-development](<https://devfeed.tech/tags/go-development.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [open](<https://devfeed.tech/tags/open.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This article explains Kubernetes's adoption of Go workspaces to simplify management of its multi-module codebase. It describes the historical use of GOPATH, staging, and Go modules, and reports that workspaces made the codebase simpler and less error-prone while reducing reliance on custom tooling and scripts.

### Source excerpt

The Go programming language has played a huge role in the success of Kubernetes. As Kubernetes has grown, matured, and pushed the bounds of what "regular" projects do, the Go project team has also grown and evolved the language and tools. In recent releases, Go introduced a feature called "workspaces" which was aimed at making projects like Kubernetes easier to manage. We've just completed a major effort to adopt workspaces in Kubernetes, and the results are great. Our codebase is simpler and less error-prone, and we're no longer off on our own technology island. GOPATH and Go modules Kubernetes is one of the most visible open source projects written in Go. The earliest versions of Kubernetes, dating back to 2014, were built with Go 1.3. Today, 10 years later, Go is up to version 1.22 -- and let's just say that a whole lot has changed. In 2014, Go development was entirely based on GOPATH . As a Go project, Kubernetes lived by the rules of GOPATH. In the buildup to Kubernetes 1.4 (mid 2016), we introduced a directory tree called staging. This allowed us to pretend to be multiple projects, but still exist within one git repository (which had advantages for development velocity). The magic of GOPATH allowed this to work. Kubernetes depends on several code-generation tools which have to find, read, and write Go code packages. Unsurprisingly, those tools grew to rely on GOPATH. This all worked pretty well until Go introduced modules in Go 1.11 (mid 2018). Modules were an answer to many issues around GOPATH. They gave more control to projects on how to track and manage dependencies, and were overall a great step forward. Kubernetes adopted them. However, modules had one major drawback -- most Go tools could not work on multiple modules at once. This was a problem for our code-generation tools and scripts. Thankfully, Go offered a way to temporarily disable modules (GO111MODULE to the rescue). We could get the dependency tracking benefits of modules, but the flexibility of G

## Write Your Go Programs Using GEdit

DevFeed: [Write Your Go Programs Using GEdit](<https://devfeed.tech/articles/write-your-go-programs-using-gedit-22085.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2013/11/write-your-go-programs-using-gedit.html>)

Published: 2013-11-23T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Development](<https://devfeed.tech/topics/development.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [Python](<https://devfeed.tech/topics/python.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [build](<https://devfeed.tech/tags/build.md>), [go](<https://devfeed.tech/tags/go.md>), [go-development](<https://devfeed.tech/tags/go-development.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [go-test](<https://devfeed.tech/tags/go-test.md>), [golang](<https://devfeed.tech/tags/golang.md>), [linux](<https://devfeed.tech/tags/linux.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [ubuntu](<https://devfeed.tech/tags/ubuntu.md>)

### AI overview

This guest post describes using GEdit for Go development and introduces GoBuild, a Python plug-in for GEdit 3.x that runs go build when Go source files are saved and runs go test for test files.

### Source excerpt

This is a guest post from Tad Vizbaras from Etasoft in South Florida. There are a number of editors and IDEs for Go development. LiteIde, Vim, Emacs and GEdit just to name a few. Each developer has their own favorite editor for each language they work with. Some like full featured IDE environments while others prefer speed over features. My personal favorite editors for Go development at the moment are Vim and GEdit. GEdit comes as part of many Linux distros. If you use Ubuntu, it is part of the operating system. GEdit has some decent features like: * Syntax Highlighting * Split Windows * Word Wrapping Advanced features are left to be handled by external plug-ins. I prefer project-less development. That means there are no formal project files and projects are preserved via a workspace bound to a directory structure. Go has excellent support for project-less development. When building and installing your projects, the Go tooling, in conjunction with the way Go packages code, can minimize the need for external scripts and makefiles. GEdit is a decent editor but I could not find any good Plug-ins that would allow me to perform a Go build right from the editor. The "External Tools" Plug-in has worked for me. I was able to set up shortcuts and get "go build" to execute. When you click on errors, displayed in the bottom pane of GEdit, the cursor jumps to exact error location. When I started programming in Go, the "External Tools" Plug-in worked for me for quite some time. But after awhile, I started to wish that "go build" would run similar to how Linters ran. With Linters, you can run a command after the file is saved. Since Go usually takes only few seconds to build, the Plug-in could execute a "go build" on save and then jump to the error location if there were any. I wrote a GEdit Plug-in that is developed in Python. Depending on the version of Python you have installed, you may require some small adjustments. This is covered in the Known Issues section below. Ops, I