Last week, I wrote an article in which I shared my thoughts on The Dark Side of Developing Open Source Software. I generally try to be balanced in my perspective on things like this, and I had planned to write this particular article at some point, but I received an anonymous comment that said the following:

wonderful issues altogether, you just received a brand new reader.
What would you suggest in regards to your post that you simply made a few days in the past?

Any positive?

The short answer is of course there are positives, so here is my experience with the benefits of developing open source software.

Benefits of Developing Open Source

I’ve previously mentioned that one of the challenges that comes with building open source software is that – just like with writing a blog – you’re opening yourself up to just as much praise as criticism.

The thing is, developers are opinionated people. When it comes to writing code, building applications, or organizing a system, we have strong opinions on how things should be done.

Sometimes, these are strong opinions, weakly held; otherwise, they are strong opinions that are often represented as the definitive way to do something.

In any respect, you’re likely to encounter all types of developers especially if you being to build – or contribute to – a popular piece of open source software.

With that said, here are the three advantages that I’ve experienced in working on open source projects.

1. You Will Become a Better Developer

Arguably, one of the most challenging things about working with open source software – especially if it’s your own – is the critique that you’ll get. Honestly, I welcome the constructive criticism because it results in me growing as a developer.

Sure, that sounds selfish, but everyone should want to increase their skill during the course of their career, right?

The first time I shared source code with others it ended up being a little bit too much to handle so I pulled it. Either I was too young, didn’t know what I was getting into, too green, or just wasn’t ready for it.

But at some point, you’ve gotta put your big boy pants on and take the criticism.

Ultimately, it pays off because you’ll inevitably learn to do more from those who know more than you. And that’s awesome.

2. You’ll Learn How To Communicate Respectfully

At one point in my life, I remember hearing that non-verbal communication was reduced to 7% of face-to-face conversation. According to an article in the ACM, this isn’t true.

I don’t know any exactly percentages, measurements, or anything like that, but I think we all know that communication via email, text, tweets, or whatever else is highly reduced. As such, we need to work hard to make sure that we do a good job not only communicating our ideas, but also do so in a clear, and respectful manner.

Whenever you’re working with others on open source software, there are going to be a lot of issues (that is, there will be open tickets in your source control software). When people open an issue, some will be very concise and unclear in what their problem is; others will provide exceptional detail (which is always helpful).

Regardless of how you respond, it’s import to be gracious that someone would take the time to open an issue because it means that they:

  1. Downloaded your work
  2. Attempted to use it
  3. Found a problem
  4. Cared enough about it to tell you about their experience

In all fairness, some people just complain. That’s the nature of the beast and there’s nothing we can do about it, but for the legitimately positive cases, some very good conversation can come from these open issues.

As you’re managing your project, you can help but learn to take the time to respectfully respond; otherwise, you run the risk of losing the people who care enough to help enhance your project.

3. You’ll Consider Other Options

As I mentioned earlier, developers are opinionated people and many times often believe that the way we (yes, we’re all guilty of this) have chosen to implement a certain solution has some level of cleverness, efficiency, optimization, and/or solid reasoning behind it.

The truth about software is that there is always more than one way to solve a problem. There’s rarely a single, right solution – ideally, it’s a matter of finding the solution that meets all of the above criteria to the greatest extent.

In order to do that, you can’t help but consider other options, and those options will often come from suggestions from others.

I can vouch for the fact that certain open source projects of mine would not be in the state they are in right now were it not for valuable input from others who showed me better, alternative ways.

But What’s The Catch?

There’s not really a catch to any of this, but if I had to distill it down to two points, it would be the following:

  • Remember not to take it personally. We’re talking about software and although our projects can often feel like our babies, they aren’t. They are bytes on a computer that we’ve shared in order to try to help others. It just so happens that in the effort to help others, others have opted to help us. Don’t forget that.
  • If you’re going to contribute to others projects, then make sure that you have a justification for whatever changes that you propose. Simply offering something “because it seems better” or because “it’s the right way” is not a justification. Instead, provide logical and coherent statements that are supported by other projects, statements, or even standards to help further your cause.

So just as much as there is a dark side that comes with working with open source software (or anything for that matter), there’s also plenty of advantages.