43: Additional Projects

You're done with the projects for this module, but I think you should spend some time creating more small projects on your own. You should know enough by now to continue copying these command line tools and creating your own little utilities. You don't need very much C++ knowledge to do that, and you'd pick up even more C++ as you continue to explore.

With that in mind, here's some ideas for things you could make right now using what you know.

Better Error Handling

All my examples didn't deal with errors at all. I might have caught an exception here or there but nothing very correct. At first dealing with errors distracts from the problem of making software. If I had you dealing with every error and learning how to use a for-loop you'd quickly get overwhelmed. You should be good enough at for-loops to start dealing with errors, so you could go back and augment the utilities you've made with better error handling.

One way to find errors is to feed your utilities garbage. Pass bad command line arguments, missing files, bad paths, incorrect files. When you find an error try to debug it and add error handling for the user. You will probably need to run your programs under a debugger to get a stack trace, so refer back to that exercise if you forgot.

Even More GNU Coreutils

If you spent the time to do every GNU coreutil you'd come out knowing almost everything you need to know about systems programming. The only issue you may encounter is Windows might not support some of the APIs you need, but you can easily skip any tools that don't make sense on Windows.

What About Windows CLI Tools?

Bored with the Unix world? There's similar tools available for windows that you can try to copy. Here's some listings you can use for reference:

• Windows CMD.exe
• Windows PowerShell

Make a TUI

A Terminal User Interface (TUI) is a fun way to create a user interface. Instead of a command line tool that takes options you use a UI library that works in the terminal. Many of these can get very complex and replace full GUIs in some cases. The nice thing about a TUI is it's a finite space so you aren't dealing with complex layout engines and graphics.

I recommend the FTXUI for C++ as a very good cross platform TUI library. Try some of the examples and see what you can create.

If you're on Linux or macOS you can try using ncurses for a less refined more old-school experience.

Create a Perfect Copy

Take any utility you've worked on and create a perfect replica. This means you copy even the bugs and weirdness. I think to do this right you'd need to get the original code for the utility and use their test suite on your version.

Automate Your Computer

I bet there's something you've always wanted and couldn't find it. Try making it. I have all kinds of little tools that I make when I run into something I need to automate. I have utilities for processing images for my games, video files for my website, testing tools, and even dumb little utilities that check my code while I work. Next time you find yourself repeating something, try to automate it.

Static Site Generator

Probably one of the best initial projects is a static site generator (SSG). An SSG does what you've been doing this whole time: read files, process files, write files. The "files" just happen to be markdown, json, and html. For this you probably want to get:

• nlohmann::json
• inja

You'll also want to find a markdown library, but you could try writing your own.

Large Projects vs. Small Projects

You may be thinking that you aren't learning how to create "real" software by making many smaller projects. The reality is that all large projects consist of a sequence of smaller projects. C++ is a very composable language, which means that you can create a component to do something, and then combine that with two other components to create a new thing. This ability to combine features and components is why small projects turn into larger projects. Each feature or idea you have in a large project simply becomes a small project inside the larger one.

So you aren't missing out. By creating many little utilities you'll also be learning how to create features for any larger projects you want to work on later.

Next Steps

In Module 3 you'll start to learn more about C++. I don't cover every C++ topic because that's impossible. C++ is such a massive convoluted language that I don't think anyone actually knows how it all works. I'm going to continue the trend of teaching you a simplified version of C++ I'm calling "Grug Brained C++." We'll learn about Object Oriented Programming (OOP), Templates, and a few other things, but it will always be with an eye to simplicity and focusing on the features actually used in the language.

If you get bored grinding little projects, take a break and do some of Module 3.