Make Things for Yourself

Forget about everyone else's problems, make things that YOU need.

A Short Backstory

I love visual explanations. Yes, it’s cliche to say something like “I’m a visual learner” (which is debunked¹) but there is real value in adding diagrams, pictures, animations and similar things to enchance a good explanation. 3Blue1Brown is the most famous creator in this space, and a big inspiration for me.

Though these kinds of lessons are great for what they are, I often find myself in a situation where I feel like I need to explore more, like asking “wait! what if we move the vector the other way instead??” and my questions are left unanswered. Similar things happen when learning from other materials like textbooks. I get many ideas like “this could’ve been explained so much better if they showed <insert idea here>” etc. Sometimes visualizing these in my mind is sufficient to understand, but often times it’s not.²

To solve this issue and try out these ideas more interactively, I started by using tools like Desmos and Geogebra. You can go pretty far by just learning the basic UI and syntax of these, they are really powerful tools. But I always had this idea of making my own library so that I can program things exactly like how I want. I basically wanted to make something that has the programmatic approach of Manim and the interactivity of Desmos / Geogebra. I want to integrate it into a blog like this, and preferrably use a framework like React which I’m already familiar with.

So, like every programmer when they find a piece of software slightly annoying or lacking, I thought to myself: “I can make something better!”

I Made Something “Better”

Here is a basic demo to get an idea. I explained it more in depth in this post. You can move the points and the slider around and see how things update. All of it is just React code, so the scenes are very flexible and easy to customize.

It ain’t much, but it’s honest work.

Is it better all of the tools I mentioned? Nope, not even close. The features aren’t even 1% of what they have, it has bugs and performance issues, and a lot more. I can’t compete with years of development (TIL GeoGebra started in 2001, it’s older than me!) and a team of developers.

But that’s okay.

You most likely can’t make something “better”. But you can make something that suits your needs better than anyone else. Create your own unique solution to your own problems.

Plus, most of these projects serve a better purpose than making something better: learning and having fun. There is no better reason than enjoying the process and improving your skills, making a good product is just a side effect.

Another thing is that, building for yourself allows you to be much more efficient. You don’t have to think about making it user friendly, having a nice API, clear documentation, and all that fluff. You can focus on the actual core functionality of it. And since you know exactly what you need, the core functionality is already decided, you don’t need to spend time figuring out what the users will want.

I’m not saying things like documentation, user experience, etc. are unimportant. But they are not important than building the thing. I noticed that worrying about these things lead to an analysis paralysis, I keep asking questions like “what if we add X in the future?”, “what if this user doesn’t like Y?” and overcomplicate things from the very start. This could be different for you, so try things out and see how it goes. If you notice you’re also getting stuck, change your mindset to think that you’ll be the only user of this thing, which often makes things easier.

Notice the Opportunities

Most programmers I see complain about not having any ideas for projects. If only they could realise how many ideas are waiting to be built right in front of them…

These projects don’t have to be some grand thing. A simple Bash script, a Python program, a small web app, an extension for your browser or editor, anything goes. I bet all of you have some small thing that annoys you in your workflow right now. Something that you probably accepted as a fact of life, you learned to live with it.

But does it really have to be this way? The whole point of engineering is to identify problems and build solutions. Why should software engineering be any different?

So many great projects started out as a personal solutions to “scratch an itch” the creator had. Only after that they became something bigger, and they started thinking about a more general audience.

Linus Torvalds did this twice. First with Linux, then with Git. The Git example is especially fitting, he created Git to manage Linux kernel’s source code when the tool he used (BitKeeper) revoked the free license. He designed it specifically with the needs of Linux kernel in mind, but it became the standard for version control because of how good it was at the time.

One example you might know if you’re familiar with Neovim is Harpoon by ThePrimeagen. He wanted a way to quickly jump between common files in a project, but none of the existing solutions were good enough (he did a whole presentation about it). So he decided to say screw it and made his own plugin. Thus one of the greatest Neovim plugins was born.

Just Start

Here is the formula:

• Observe your own workflow, the apps and tools you use.
• Whenever you find yourself thinking “this kinda sucks” or “I wish it was a little different”, write that down.
• Start building a solution to make things better. Don’t think about anyone else using it, just make what you need right now.
• Start using your own solution, so you can see how it works in practice and iterate.
• (Optional) If you think it might be useful to others, make it public.
• (Optional) Then you can worry about polishing it and making it more usable for a wider audience.

That’s all. Observe, notice, and build.