Gain insights into writing professional command-line programs in Go. Delve into structuring Go programs, writing idiomatic code, testing effectively, and impressing users and managers.

write professional command  - line programs in Go.png

data.tar.gz

Go run main.go

Run main.sh

Run go test

Run go test2

GoLive

GoLiveTesting

Multi-git-Custom

Pre+main-v0.2

Main_to_cmd

Run go test-Coverage

Ginkgo

Ginkgo-BDD

Ginkgo-e2e

Cobra

Cobra-NoInstall

Cobra-NoInstall-FullApp

Final_Cobra_Multi-git

Viper

Viper-etcd

Viper-Cobra

SelfUpdating

Make

Special build

Embedding_Data

Go run main.go-Simple

In this course you will learn why Go is an awesome language for writing command-line programs. You will learn how to structure your Go programs, how to write idiomatic Go code, how to test your programs and how to amaze your users, peers and managers. 

The focus is on command-line programs in order to keep the course down to earth, but most of the principles and best practices you will learn apply to any Go program.

Write Professional Command-line Programs in Go

# Common directory structures for Go programs

We identified common elements of a Go program, but, how do we go about organizing them in a directory structure? We will discuss several common approaches.

## Flat single directory

The flat single directory approach has no internal structure. All the files live in the project's root directory. This is the approach used by multi-git 0.1, and it is appropriate for very small programs.

## The minimal approach

The minimal approach advocates just two top-level directories: `cmd` for executables and `pkg` for libraries. For each command and package, there will be a sub-directory under the respective `cmd` and `pkg` directories. Every other file that belongs to a specific command or package will live in their sub-directory. Project-level files live in the project's root directory.

The main benefit of this approach is its simplicity. The top-level structure of the project is very clear. The downside of this approach is that it doesn't help organize the code inside commands and packages. Large programs have many concerns and files beyond just Go files. 

## The comprehensive approach

The comprehensive approach advocates a separate top-level directory for every major aspect of the program. What are those aspects can differ from project to project. Check out https://github.com/golang-standards/project-layout for an extreme variant with 19 top-level directories. Of course you  don't have to use ALL those directories.

# The multi-git directory structure

For multi-git, we chose a pretty minimal directory structure with just three top-level directories: `cmd`, `pkg`, and `e2e`. We know all about `cmd` and `pkg`, but what is `e2e`? It's a directory that contains end-to-end tests. Those tests don't belong in a package and I don't want to add them to the `cmd` directory where they will be mixed with other executables. Without further ado, here is the new multi-git top-level directory structure:

```
$ tree -L 1
.
├── LICENSE
├── README.md
├── main.go
├── cmd
├── pkg
├── e2e

```

# Conclusion

A consistent and well-organized directory structure is essential for large programs developed by multiple developers. Go has several distinct elements such as packages and commands that it makes sense to organize in separate directory hierarchies. There are several popular directory organization schemes in the Go community, but no formal standard. For multi-git, we will use a simple directory structure with top-level directories for commands, packages, and end-to-end tests.

# Quiz


In this lesson, you will learn about some best practices that emerged in the Go community when building large-scale programs. Then, you'll select a directory structure for multi-git.

Creating the Directory Structure

Overview

Restructuring multi-git

Testing 1,2,3...

Adding Smart Command-Line Parsing

Adding Advanced Configuration

Adding Bells and Whistles

Summary

Creating the Directory Structure

Common directory structures for Go programs