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.

About the Author: Elliott Minns

Elliott Minns thumbnail

Elliott Minns is a software developer and creator of educational YouTube channels Dreams of Code and Dreams of Autonomy, where he shares knowledge about autonomous software, open source, and self-hosting.

He actively discusses technologies such as Linux, NixOS, analysis and development tools, and strives to help developers become more independent in building infrastructure.

Elliott also runs public projects on GitHub (such as dotfiles configurations) and participates in podcasts, sharing his approach to software autonomy and open technologies.

Previously, he worked as a freelancer, specializing in cryptocurrencies and decentralized applications.

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