Open Source: Philosophy and Contribution — From Passenger to Citizen

I still remember the moment I first felt "in debt" to someone I never knew. At that time I was working on Blogspot in 2013, I was stuck on a CSS problem that made the layout messy in Internet Explorer. After two days of headaches, I found the answer on a forum — posted by someone from who knows where, patiently written, complete with an explanation of why the solution worked. Free. Without asking anything.

Years later, the same pattern continues to repeat itself. The Nginx I use for all my servers? Free. Linux that turns a used laptop into a home server? Free. Playwright do I use for browser automation? Free. Nearly the entire technology stack I use every day was built by people who chose to share their work publicly.

This article is not a tutorial. This is more of a reflection — about why open source works, why people want to share it for free, and what it means to "contribute" for those of us who feel like we're not as good as the maintainers out there.

Open Source Isn't Just About Free Code

If open source was just about "free software", it wouldn't have lasted this long. Many paid software have gone bankrupt and been lost to time. What makes open source survive is its philosophy: code that can be seen, studied, changed, and shared again.

There's an analogy I use to explain this to non-technical friends. Imagine two soto stalls. The first stall kept its recipe under wraps — only the owner knew the spice measurements. If the owner retires or the shop closes, the recipe is lost forever. The second stall sticks the recipe on the wall. Anyone can read it, can imitate it, can even modify it and open their own shop with a different version. This recipe will never be lost, and instead develops because many hands have perfected it.

That's what happens with Linux. Starting from a fun project by Linus Torvalds in 1991, Linux now powers the majority of servers in the world, all Android phones, the fastest supercomputers, even the TP-Link routers in our homes. Not because it's free — but because thousands of people from all over the world are helping to improve it, each contributing according to their ability.

Why do people want to share for free?

This question often arises, especially from people who see everything from a transactional perspective. "I'm tired of writing code, why give it away for free? It's a loss."

From my experience of observing (and feeling a little bit), there are several reasons why people keep sharing:

First, pay the debt forward. Almost all open source developers started their careers by using other people's work for free. Contributing is their way of “giving back” — not to the same people, but to the ecosystem. It's like a digital version of mutual cooperation: I draw from the same well, so I help keep the well flowing.

Second, open code is better. When you share code, other people will find bugs you didn't see, suggest approaches you didn't think of, and use your code in scenarios you never imagined. Criticism from the public is free — and often more valuable than paid code reviews.

Third, reputation and learning. A public repository is a portfolio that cannot be faked. Many developers get good jobs not because of their diploma, but because of their commit history on GitHub. And writing code that other people will read forces us to write neater code — just like public speaking forces us to organize our thoughts.

Fourth, there is satisfaction that cannot be bought. When I published the browser and office repos (b.lan and o.lan projects) to GitHub, no one immediately gave me anything. But knowing that the documentation might help someone out there who has the same problem — a home server without a desktop environment that can still be used remotely — feels like it's leaving a useful trail.

Contributions Do Not Have to Be Code

This is the part that I think is most often misunderstood. Many people back away from open source because they feel like they're "not good at coding" or "my code is bad, it's embarrassing for people to see." Even though the contribution has a very wide spectrum:

• Report bugs well. Clear bug reports — reproduction steps, software versions, complete error messages — are invaluable to maintainers. Many critical bugs are found by regular users, not developers.
• Write and improve documentation. Documentation is the part that is most often neglected. Fixing typos, adding examples, or translating documentation into Indonesian is a real contribution.
• Answering questions on forums or issue trackers. Remember the stranger who answered my CSS question in 2013? He is not the developer of that library. He's just the user who found the answer first.
• Write articles and tutorials. Every blog article that explains how to use a tool is a form of contribution. You extend the life of that knowledge and make it discoverable via search engines.
• Donation or sponsorship. If you really don't have the time, a small financial support to the maintainer of the tools you use every day is also very meaningful. Many important projects are supported by donations of tens of thousands of rupiah from many people.

Licenses: Frequently Ignored Rules of the Game

One thing anyone using open source needs to understand: "accessible" does not mean "free without rules." Every project has a license, and that license has consequences.

MIT and BSD are permissive — you can use, modify, even sell, as long as you include the original copyright. The GPL is more strict — if you modify and distribute, the results of the modification must also be decoded. There are also licenses such as the AGPL that even regulate use over a network.

Respecting licenses is part of etiquette. Just as we wouldn't take vegetables from a neighbor's garden just because the fence is open — openness does not mean that ownership is eliminated. Precisely because the rules are clear, all parties can share calmly.

From Consumer to Citizen

If I had to summarize the open source philosophy in one sentence, it would sound like this: don't just be a passenger, be a citizen.

Passengers simply get on, sit down and get off at their destination. Residents took part in sweeping bus stops, reporting if street lights were out, and showing directions to people who were lost. The open source ecosystem doesn't need everyone to be a genius programmer. He needs a lot of people who care just a little bit — consistently.

For those of you who have been using Linux, Nginx, PHP, MySQL, or other free tools and want to start "paying off debt", start small: report the bugs you encounter in full, fix a typo in the documentation, or write about your experience using the tool on a blog. No need to wait to become an expert first. In fact, by participating, you will learn much faster than learning alone.

This well continues to flow because many people draw from it in an orderly manner and take part in maintaining it. It's our turn to take care of it — so that ten years from now, there are other vocational school students in Semarang who are stuck on CSS problems, and find the answer from our writing.

Have experience contributing to open source, or still unsure about starting? Tell me in the comments column — I want to know your version.