The Right - And Wrong - Reasons to Open Source Software
Here's a rundown of the right and wrong reasons to choose open source as a pathway forward so developers and businesses can make an intelligent, informed decision.
Join the DZone community and get the full member experience.Join For Free
It's no secret that the average software developer tends to love writing code. In many ways, that's almost a prerequisite to doing the job in the first place. But that desire to create can come with a steep price. It's that developers can have a hard time deciding what to do with the work they've poured their creativity and energy into.
For most, the choice comes down to two options: keeping their software proprietary or choosing to make it open source. In recent years, the open-source community has grown exponentially, and that comes with some significant perks. But it can be hard for a lone developer (or a business) to find sustainable paths to profit from their work if they choose to go that route too early in development.
So, to help developers and businesses make that all-important decision on which way to go with their software development projects here's a rundown of the right and wrong reasons to choose open source as a pathway forward so they can make an intelligent, informed decision.
The Right Reasons to Choose Open Source
There are some major advantages to making a code library or a piece of software open source, many of which apply in a variety of diverse situations. At this stage, I'd even go as far as to say that the positives outweigh the negatives in most situations. Those reasons include:
1. The Chance to Build a Thriving Community
When creating a new piece of software, it's often difficult to get people on board with your idea, and sometimes even harder to convince people to commit to using it. But open-source projects tend to attract like-minded developers and real-world users into thriving communities who are committed to making the software better. And those communities are a major asset – serving both as real-world testers as well as valuable sources of new ideas, knowledge, and features for the software itself.
2. Cement Software Viability
Since open-source software turns users into true stakeholders, it helps the software to achieve early viability that has real staying power. Closed-source projects, by comparison, feature users that are at the mercy of the developers' desire to listen and be responsive to their needs. That means they won't hesitate to jump ship to a competitor if their needs aren't met (unless your software is priced to discourage defections). With open-source software, users can opt to create needed features and advance a project's development however they wish. That makes them more likely to stick around for the long term.
3. Create Market Demand
As odd as it may sound, developers and businesses have a better chance of creating a demand for their products by attaching open-source libraries and software to them. Consider, for example, how AMD partnered with the open-source community to extend support for its graphics chips in Linux-based systems. Their open-source drivers are now seen as better, faster, and more stable than those of rival Nvidia, giving AMD a substantial advantage with Linux devotees.
4. Reduced IP Concerns
Even though businesses that opt to open-source some of their software still have to worry about protecting their intellectual property (IP). It's just that with open-source licensing, the scope of what they must protect is reduced and the measures they have to take aren't as onerous. For example, a company with proprietary software IP might have to turn to a company like Firmex.com to set up a secure virtual data room if they needed to allow any third party to audit or otherwise review their code. In an open-source model, a business mostly has to worry about competitors using their innovations outside the scope of the open-sourced project itself, and that's much easier to defend against compared to trying to enforce non-disclosure agreements and keeping code a secret – just ask Microsoft.
The Wrong Reasons to Choose Open Source
Even with everything the open-source model has going for it, there are still plenty of bad reasoning developers and businesses use when making the decision. Those poor reasons include:
1. Capitalizing on the Work of Unpaid Developers
Even though it's something regarded as a positive (see above), making a project open source often brings with it significant contributions from coders and enthusiasts all around the world – and those contributions can be worth quite a bit of money and change the nature of the project for its originators. In general, if the project can't succeed without the hard work of volunteer contributors, then open-source is a fine way to go. But there's no going back without serious risk. Major open-source projects like Emby have suffered significant backlash from developers when reverting to closed-source. Even if a project evolves in a way where the move makes sense – it's going to engender some serious ill-will from users and members of the project's community.
2. Sustaining an End-of-Life Product
In recent years, some software user groups have taken to pressuring software developers and businesses to get them to open-source software that has reached end-of-life status. On the face of it, the move seems to make sense. The trouble is, doing this immediately takes the original developers out of the driver's seat and can expose users to all kinds of turmoil during the transition. It may also threaten the developers' ability to transition users onto newer, better, software solutions. At best, it will fragment the market the software's meant to address, and that's rarely a good thing.
3. Offloading Responsibility
Even though it might be nice for a project's developer to get some help turning their code into a great finished product, that should never be the sole justification for going open source. Many developers have sought help in this way, only to see a project grow exponentially – often out of their control – and turn into something they never intended. If the original work is important to the person or business that open-sourced it in the first place, that might lead to their own vision for the software getting drowned out by the larger community. In other words – if a developer wants less responsibility to get things done, but isn't comfortable giving up control, they should think long and hard before making their project open-source.
The Bottom Line
Put simply, choosing to open source a piece of code or software isn't a decision to undertake lightly. It's something that requires plenty of careful thought to determine what the long-term ramifications of such a move might be. Of course, there's plenty of good reasons that open source software has gained so much traction in recent years. But it's not the only way to develop, no matter how attractive an option it is.
And it's important to recognize that there's always going to be a role for proprietary software – even if many people consider it a dead or dying model. There are good reasons for that, too. After all, there are some situations where developers have a need to protect their work from being used in ways they don't agree with or to see it used by a competitor to undermine their market position.
Hopefully, though, the reasoning discussed here – both right and wrong – will help developers and businesses make smarter choices when it comes to choosing whether or not to open source their work. And the rest, as they say, is up to them.
Opinions expressed by DZone contributors are their own.