Fantastic Side Projects and Where to Find Them

So you are a newbie developer looking for a project idea to apply what you've learned in that Udemy course, or maybe an experienced engineer searching for the next side project to work on for fun. Either way, you need a creative idea to bring to life.

It's a fun way to apply what you have learned in the courses/books and an excellent skill to craft the tool you just need to automate that boring stuff you need to do every day.

Here, I will list a few sources/techniques I used to find cool project ideas while learning programming and now to craft useful tools for my needs. This blog post is a little bit opinionated. Everyone has a unique learning curve, so if you find my suggestions harder or easier than expected, it's okay to modify them to fit your level.

you have just started learning programming...

...and looking for project ideas. You probably know Python or JavaScript a little bit, or maybe C/Go, and want to dive into interesting real-life stuff.

In this stage, you should not dive right into big and complex projects. I know it's exciting, but hear my reasons:

1. You probably don't have the technical background required to build a complex system. Whether it's creating a browser, a search engine, a social media app, …. These projects seem simple from the outside. "I mean, you just enter a search text, and it lists some websites", yes, but in the background, there are too many moving parts and some pretty complex algorithms for a beginner. For a browser, you need to write a JavaScript parser; for a search engine, you at least need to understand graphs, and so on.
2. You may not have the ability to read other people's code. Building complex stuff requires the skill (yes, it's kind of a skill) to read long lines of production code to see how other engineers solved similar problems. Also, you can't always find blog posts/videos/docs explaining "how to do X" after a certain level of problem complexity.

However, the most beneficial thing you can do is code simple yet not tedious stuff using the programming topics you learned to jump to advanced levels where you can work on complex projects as fast as possible.

I suggest coding simple versions of those complex programs, such as creating little terminal-based games. You don't need to learn GUI, a self-made hangman game is still fun after all. Also, while building one, you will need to use most of the topics you've learned/are learning: fundamental data types, variables, control flow (conditionals, loops), terminal input/output, etc…

Another one may be a simple chatbot in the terminal. It gives you a list of prompt options, you select one, and it prints a defined answer for the fixed prompt. It's like a super simple version of ChatGPT - you don't need to design and code all the frontend, backend, and ML stuff.

you had some time with a programming language and can write basic programs

Perfect! Now you are ready to step up your game a little bit and start learning and applying CS fundamentals in your programs to reach a higher level of complexity:

• Basic data structures. Array, linked list, tree, hash map, and stack/queue data structures are in this category.
• Basic algorithms.
• File operations. You won't only interact with the user via the terminal input all the time. Sometimes, you need other communication mediums, and one of the most fundamental ones is through using a simple file.

In this stage, you can add more functionality to the programs you have created until now, adding dynamism by implementing:

• Updating the program data during runtime
• Not-strictly-defined user interactions

The idea is forcing yourself to use a new data structure/algorithm in every project you create.

Let's say you have a program that gives you the information of students when you enter the name of one. You can enhance this program to run in a loop that takes the student name, gives the info, then asks the user if they want to update the information. To do this, you will need to use a data structure (linked list, for example) instead of hardcoded data. Then, you will need to use a search algorithm to find specific students given the name.

Adding more functionality pushes you to utilize new stuff in your code, which is an excellent way to learn and practice new concepts in programming.

you are fluent in a programming language and know basic CS theory

This is the time you need to start learning more advanced stuff. Such as:

• Storing and retrieving application data. How/when to use JSON/CSV files, SQL databases, caches, message queues, data serialization algorithms, etc.
• Interprocess communication. This is where the distributed systems practically begin. As the complexity increases, you will need your programs to talk to each other.
• Beyond basic data structures and algorithms. You can put graphs, tries, B+ trees, and bloom filters in this category. These data structures are used inside browsers, databases, search engines, and many more complex systems.

In this stage, you can try to design and implement your own version of existing stuff you use, such as creating your own programming language and writing a compiler for it, trying to write your own database engine with indexes, basic queries, and maybe aggregations.

You don't have to go with a fully functional clone; for example, creating a programming language with just integer types as the native type is a good exercise, and it's still challenging!

Here are some practical resources and project ideas:

• Try to read the Python source code. The official implementation¹ is done in C, and it's a good exercise to go over and try to understand how the native data types (int, list, dict, etc.) are implemented, how did they handle memory management, and so on.
• If you are fluent in Python and can code at least a little bit of C, try to write a Python extension²
• Try to design and implement your own programming language. This is a fun project because until now, you were on the consumer side of the languages (if you did not contribute to a programming language), and now you will be on the creator side! Interpreters and compilers are complex computer science topics, but you don't need to know them in detail to implement a simple language processor.
• Create a blog engine. You can develop your own static site generator³ and start blogging using your own blog engine. Checking some of the popular static site generators, such as Hugo⁴ and Zola⁵, can help determine which features to implement in your engine.

Some good resources worth reading/checking for compiler/interpreter design:

• Writing An Interpreter In Go - Book by Thorsten Ball, going through the steps of writing an interpreter from scratch for a toy programming language
• Writing A Compiler In Go - Book by Thorsten Ball, sequel to Writing An Interpreter In Go
• Crafting Interpreters - Book by Robert Nystrom, a good read on interpreter internals
• Compilers: Principles, Techniques, and Tools - The Dragon Book. Maybe the most popular compiler book among the CS students :)
• A Compiler Writing Journey - GitHub repo of a self-compiling compiler project. There are implementation notes for all parts, it's worth checking out.

you are capable of designing and implementing complex stuff

This blog post became longer than I expected, and it's been a while since I started writing, so I will write another one just for this subtopic 🤷‍♂️

that's all!

I hope you found this content useful. I will add sequels to this post, writing about my side projects or other resources to find fun side project ideas in the future.