CourseFlix

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

Course content

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

Related courses

  • Learn to Create Web Applications using Go thumbnail

    Learn to Create Web Applications using Go

    By: useGolang (Jon Calhoun)
    Why can't anyone point me to a concrete example of how to hash and store user passwords? Or how to build the rest of an authentication system?
    43 hours 35 minutes 37 seconds
  • Getting Started With Golang thumbnail

    Getting Started With Golang

    By: Academind Pro (Maximilian Schwarzmüller)
    Learn all the key fundamentals of Go - one of the most in-demand and popular programming languages you can learn these days!
    15 hours 19 minutes 14 seconds
  • The Ultimate Guide to Debugging With Go thumbnail

    The Ultimate Guide to Debugging With Go

    By: ByteSizeGo, Matt Boyle
    The most important skill you were never taught. The ability to debug code locally and in production is critically important for any Go engineer.
    3 hours 41 minutes 59 seconds

Frequently asked questions

What is Command Line Applications in Go about?
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…
Who teaches Command Line Applications in Go?
Command Line Applications in Go is taught by Elliott Minns. You can find more courses by this instructor on the corresponding source page.
How long is Command Line Applications in Go?
Command Line Applications in Go contains 129 lessons with a total runtime of 27 hours 11 minutes. All lessons are available to watch online at your own pace.
Is Command Line Applications in Go free to watch?
Command Line Applications in Go is part of CourseFlix's premium catalog. A CourseFlix subscription unlocks the full video player; the course description, table of contents, and preview information are available to everyone.
Where can I watch Command Line Applications in Go online?
Command Line Applications in Go is available to watch online on CourseFlix at https://courseflix.net/course/command-line-applications-in-go. The page hosts every lesson with the integrated video player; no download is required.