CF

Command Line Applications in Go

27h 11m 52s
English
Paid

Command Line Applications in Go is a practical course designed to enhance your programming skills in Go by creating command-line applications. Under expert guidance, you will incrementally master the development of CLI utilities, ranging from basic console tools to sophisticated TUI applications that can rival web interfaces.

What You Will Learn

Throughout the course, you will not only delve into Go programming but also gain insights into:

  • Reading and writing data to files and streams effectively;
  • Handling user input and output seamlessly;
  • Parsing command line parameters expertly;
  • Utilizing advanced Go features such as concurrency and channels;
  • Testing code to ensure its reliability and robustness;
  • Crafting network applications;
  • Designing command interfaces and interactive TUI programs;
  • Managing data stores like BadgerDB and SQLite;
  • Packaging and distributing your finished applications.

What You Will Create

By the end of the course, you will have developed several practical CLI applications, which include:

  • A utility for counting lines and words in a file with precision;
  • A sophisticated tool for generating git messages using the OpenAI API;
  • A robust program for compressing and decompressing data using gzip;
  • A console application for effortless data storage and retrieval directly from the terminal.

Who Is This Course For

This course is perfectly suited for individuals aiming to learn Go from the ground up or aspiring to develop their own CLI tools.

Go stands out as one of the premier languages to acquire proficiency in by 2025, offering an ideal blend of high performance, modern syntax, and memory and type safety.

Additional

  • https://github.com/dreamsofcode-io/vibe

About the Author: Elliott Minns

Elliott Minns thumbnail

Elliott Minns is a software engineer and educator focused on practical Go (Golang) tutorials, particularly the production craft of building command-line tools.

His CourseFlix listing carries Command Line Applications in Go — a structured treatment of building production-quality CLI tools in Go: argument parsing, the cobra / urfave-cli framework choices, the testing patterns, the cross-platform release workflow, and the engineering decisions that separate polished CLI tools from generic command-line scripts.

Material is paid and aimed at Go developers shipping CLI tools as a deliberate product category. For broader content, see CourseFlix's Golang category page.

Watch Online 129 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 129 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: 1. Introduction to the course
All Course Lessons (129)
#Lesson TitleDurationAccess
1
1. Introduction to the course Demo
02:59
2
2. Welcome!
04:58
3
3. Setting up your environment
15:28
4
4. Go 101- Variables, Values & Types
24:34
5
5. Go 101- Conditionals & Loops
19:27
6
6. Go 101- Functions & Pointers
17:10
7
7. Go 101- Packages
12:45
8
8. Starting a new project
12:42
9
9. Reading from a file
11:24
10
10. A Simple Word Counter
09:31
11
11. Writing te
15:35
12
12. Edge cases
10:36
13
13. Table Driven Testing
13:12
14
14. A better algorithm
15:24
15
15. Introduction to input
02:20
16
16. Exit codes
05:40
17
17. Standard error
11:11
18
18. Reading large files
23:28
19
19. Bytes & ascii
15:13
20
20. Unicode & Runes
18:05
21
21. The bufio package
08:35
22
22. Decoupling & io.Reader
08:58
23
23. Command line argume
09:10
24
24. Handling multiple errors
16:06
25
25. Closing files with defer
08:21
26
26. Standard input
08:05
27
27. Scanning data
19:47
28
28. Adding new features
05:47
29
29. Counting lines
11:48
30
30. Counting bytes
10:33
31
31. Encapsulation
10:42
32
32. File offs and seeking
18:45
33
33. Methods
17:05
34
34. Variadic parameters
07:02
35
35. Method receivers
11:49
36
36. CLI flags
25:14
37
37. Single pass algorithm_2
08:54
38
38. Tabular output
15:00
39
39. Organizing our code
13:32
40
40. Package visibility
09:23
41
41. Constructor argume
06:41
42
42. Whitebox vs Blackbox testing
11:25
43
43. Introduction to concurrency & data
01:28
44
44. Goroutines & Waitgroups
12:02
45
45. Channels
12:47
46
46. Handling async errors
14:17
47
47. io.TeeReader
06:00
48
48. io.Pipe
08:00
49
49. io.MultiWriter
05:07
50
50. Introduction to Advanced Testing
01:10
51
51. Benchmark testing
09:26
52
52. End to end testing (e2e)
15:09
53
53. e2e- Testing files
13:06
54
54. e2e- Multiple files
17:54
55
55. Determinstic output
11:35
56
56. e2e- Testing flags
05:37
57
57. Creating test helpers
18:45
58
58. Executing commands
09:00
59
59. Passing in input
08:18
60
60. Configuring commands
09:21
61
61. Asynchronous execution
15:07
62
62. Signals
13:43
63
63. Graceful shutdown
07:25
64
64. Cancellation
17:02
65
65. context.Context
17:14
66
66. Building a process guard
22:31
67
67. Opening an editor
09:53
68
68. Fuzzy finding with fzf
09:32
69
69. Introduction to Networking & Files
03:20
70
70. File flags
11:10
71
71. File permissions
20:21
72
72. Walking the filesystem
18:13
73
73. Lockfiles & PIDFiles
16:50
74
74. File locks
08:25
75
75. The net package
09:29
76
76. TCP Client
03:05
77
77. DNS lookups
03:18
78
78. Port scanning
07:26
79
79. The net-http package
17:32
80
80. Marshaling & unmarshaling data
15:31
81
81. Sending files with HTTP
08:05
82
82. Testing HTTP Reque
09:20
83
83. Introduction to Powerful CLI Apps
01:35
84
84. Subcommands
12:57
85
85. Flags
15:05
86
86. Subcommand Abstraction
21:42
87
87. Compressing files & data with GZip
24:28
88
88. Hashing files & data
15:38
89
89. Password & Secure Input
20:32
90
90. Have I been pwned.
15:33
91
91. Environment variables
12:04
92
92. Configuration files
16:32
93
93. Advanced Error Handling
20:01
94
94. Embedding Files
09:28
95
95. Cross platform code
15:31
96
96. Build flags
11:36
97
97. Regular expressions
14:19
98
98. UI- A Loading Spinner
15:37
99
99. UI- A Progress Bar
17:27
100
100. Adding color to Stdout
09:24
101
101. Working with images
19:56
102
102. Distributing an application
15:21
103
103. An Application Builder
08:27
104
104. Handling CGO
14:55
105
105. Introduction to Popular CLI packages
03:18
106
106. Subcommands with Cobra
13:54
107
107. POSIX flags with pFlag
19:23
108
108. Storing data with SQLite
28:38
109
109. Database Migrations with Migrate
24:15
110
110. Repositories with SQLc
16:32
111
111. Color with color
09:21
112
112. TUI with Bubble Tea
18:32
113
113. Forms with huh
15:02
114
114. Test assertions with Testify
18:14
115
115. Mocking with go-mock
33:34
116
116. Releasing with Go releaser
11:27
117
117. Introduction to Final Project
01:27
118
118. Project setup
04:17
119
119. Obtaining staged changes
09:04
120
120. Installing Ollama
05:25
121
121. Prompting the LLM
15:07
122
122. Commiting our messages
06:17
123
123. Adding in a spinner
07:27
124
124. Adding another provider
11:05
125
125. Adding in CLI flags
19:55
126
126. Provider registration
14:57
127
127. Integration testing
16:52
128
128. Homework and improveme
09:02
129
129. Conclusion and closing remarks
02:41
Unlock unlimited learning

Get instant access to all 128 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
Before starting this course, students should have a basic understanding of programming concepts. Familiarity with Go is beneficial but not required, as the course begins with foundational topics such as variables, conditionals, functions, and packages in Go.
What type of applications will I learn to build in this course?
The course focuses on developing command-line applications. You will build various practical tools, including a file word counter, a git message generator using the OpenAI API, a data compression tool using gzip, and a console application for data storage and retrieval.
Who is the target audience for this course?
This course is ideal for individuals looking to learn Go from scratch or professionals seeking to enhance their skills in developing command-line applications. It is also suitable for developers interested in exploring the use of Go for creating CLI utilities and TUI programs.
How does the course depth compare to other programming courses?
The course provides a thorough exploration of Go for building CLI applications. It covers advanced topics like concurrency, channels, and network applications, offering a comprehensive understanding beyond basic Go programming, especially in the context of command-line tool development.
Which specific tools and platforms are covered in the course?
Students will learn to use tools and libraries such as the bufio package for handling I/O operations, concurrency features like goroutines and channels, and data stores like BadgerDB and SQLite. The course also covers packaging and distributing applications effectively.
What topics are not covered in this course?
The course does not cover GUI application development or other programming languages outside of Go. It focuses specifically on command-line applications and related Go features, without exploring web development or mobile application development.
What is the time commitment required for this course?
The course consists of 129 lessons. While the total runtime is not specified, students should be prepared to invest a substantial amount of time to engage with the lessons, complete exercises, and build the projects to gain the full benefit from the course.