CF

The Art of Command Line Interfaces

5h 51m 42s
English
Paid

Unlock the secrets of crafting high-quality CLI applications with Go! No one has delved deeper into the art of creating exceptional command-line interfaces than Marian, the acclaimed author of *Building Modern CLI Applications with Go*. Her expertise in Go extends beyond just HTTP servers, offering a wealth of knowledge on developing elegant and idiomatic CLI applications.

Join Marian as she imparts her extensive experience through this comprehensive video course. Marian has also shared her insights at Gophercon, further proving her mettle in this niche field.

Course Highlights

  • Over 5 hours of in-depth material: Dive deep into the world of CLI applications.
  • Beginner-Friendly: No prior CLI experience necessary. Start with the basics and gradually progress to advanced levels. Note: Programming experience in Go is required.
  • Hands-On Learning: Engage in step-by-step practical assignments designed to reinforce learning at every stage.

About the Authors

ByteSizeGo

ByteSizeGo thumbnail

ByteSizeGo is a Go-focused course platform run by Aaron Lee, focused on the production / debugging side of Go engineering rather than language tour material. The platform's distinctive contribution is the Foundations of Debugging series, which teaches the systematic skill of debugging Go services in production rather than relying on ad-hoc print statements.

The CourseFlix listing carries six ByteSizeGo courses: Foundations of Debugging for Golang, The Ultimate Guide to Debugging With Go, The Anatomy of Go, Building Production-Ready Services with gRPC and Go, AI Engineering with Go, and The Art of Command Line Interfaces. Material is paid and aimed at working Go developers ready to deepen the operational side of their craft.

Marian Montagnino

Marian Montagnino thumbnail

Marian Montagnino is a software engineer and educator focused on the production craft of building command-line interfaces, particularly in Go.

Her CourseFlix listing carries The Art of Command Line Interfaces — a structured treatment of CLI design: the user-experience patterns, the argument-parsing decisions, the output formatting patterns, the publishing workflow, and the engineering patterns that distinguish polished CLI tools from generic command-line scripts.

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

Watch Online 40 lessons

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Welcome to the course!
All Course Lessons (40)
#Lesson TitleDurationAccess
1
Welcome to the course! Demo
00:43
2
Introduction
02:48
3
Creating a Simple CLI
04:58
4
Adding a Logger
07:26
5
Adding silent & verbose flags
11:39
6
Intro to flag.Parse()
01:03
7
Handling a list of URLs
06:42
8
Customizing help output
06:38
9
Exercise Walkthrough
09:29
10
Introduction
02:24
11
Setting up a new structured logger
15:33
12
Adding Check & Monitor Commands
17:11
13
Adding Command Hooks
02:48
14
Using the Context to Manage Global Cancellation
11:52
15
Creating a Version Command
08:19
16
Exercise Solution
17:53
17
Introduction to Testing CLI Applications
05:37
18
Writing Unit Tests
09:11
19
Mocking HTTP Calls
19:45
20
Using ExecuteC to test Cobra Commands
13:11
21
Exercise Solution
07:15
22
New output flag - JSON, Text, Table output (tablewriter)
14:21
23
Use spinner bar for a single URL check
04:44
24
Create a monitoring table showing the url, and the status with dynamic updates
03:57
25
Add color for up/down statuses
02:55
26
Adding Auto Complete
05:59
27
Exercise Solution
03:10
28
Introduction
04:10
29
Creating Custom Errors
03:27
30
Advanced logging techniques - log rotation and more!
15:03
31
Graceful Errors & Interactivity
06:38
32
Exercise Solution
12:11
33
Release Automation
03:19
34
Containerizing with Docker
10:00
35
Initial Automated Cross-Compilation Workflow with GoReleaser and Github actions
16:03
36
Automated Homebrew distribution
09:11
37
Automated Chocolatey distribution
19:18
38
Automated Docker distribution
08:16
39
Automated RPM and Deb files
08:39
40
Exercise Solution
17:56
Unlock unlimited learning

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

Learn more about subscription

Related courses

  • Build Your Own Database in Go From Scratch thumbnailUpdated 2y ago

    Build Your Own Database in Go From Scratch

    By: James Smith
    Study databases from scratch by creating your own, step by step and with simple code in Go (language-neutral). Atomicity and durability.
  • Full Time Go Dev thumbnailUpdated 2y ago

    Full Time Go Dev

    By: Full Time Go Dev
    Rocket Fuel you GO career with the Full Time Go Dev Mastery. These secret techniques will make everyone say "WOW" while you destroy any GO task with the.
    42h 44m3/5
  • Redis Internals thumbnailUpdated 10mo ago

    Redis Internals

    By: Arpit Bhayani
    Redis Internals by Arpit Bhayani — self-paced course rebuilding Redis's key features in Go. Master database design, replication, and persistence.
    9h 6m5/5

Frequently asked questions

What prerequisites are needed before taking the course?
The course is designed to be beginner-friendly in terms of CLI application development, meaning no prior experience with CLI is necessary. However, it does require programming experience in Go. This ensures that students can effectively engage with the various exercises and understand the advanced topics covered.
What projects or applications will I build during the course?
Throughout the course, you will build several CLI applications. These include creating simple CLIs, adding logging functionalities, managing URL lists, and implementing monitoring tables with dynamic updates. You will also work on projects involving structured logging, command hooks, and custom error handling. These exercises are designed to reinforce your learning and provide practical experience.
Who is the target audience for this course?
The course is ideal for Go programmers who are interested in expanding their skills to develop command-line interface applications. It caters to those who want to learn how to create robust, idiomatic CLI tools using Go and is particularly beneficial for developers looking to enhance their tooling or automate tasks using the command line.
What specific tools or libraries will be used in this course?
The course covers a variety of tools and libraries essential for CLI development in Go. Key tools include tablewriter for output formatting, Cobra for command handling, and GoReleaser for automated workflows like cross-compilation and distribution. These tools are integral to building and distributing professional-grade CLI applications.
What topics are not covered in this course?
While the course is comprehensive in CLI application development using Go, it does not cover topics outside this scope, such as GUI application development, web server programming, or non-Go programming languages. The focus remains on leveraging Go to build and automate command-line tools.
How much time should I expect to commit to this course?
The course includes over 5 hours of video content spread across 40 lessons. Given the practical nature of the exercises, additional time may be required to complete assignments. Students should expect to allocate time beyond the video runtime for hands-on practice and to fully grasp the concepts presented.
How can the skills learned in this course benefit my career?
Skills acquired in this course are highly transferable to various roles in software development. Proficiency in CLI application development enables automation of tasks, enhances productivity, and extends the functionality of existing systems. Additionally, the knowledge of Go and related tooling can be advantageous in roles focused on backend development and DevOps.