Technical advantages of open source software
The main motivation for open source software is the social, ethical and organizational advantages of open source over proprietary software.
For example, open source has a larger pool of possible contributors.
The technical advantages of open source over proprietary software are far less frequently discussed,
and sometimes people are not even aware they exist.
Open source gives you options that are impossible with proprietary software,
though you might choose not to take those options in practice.
Here's a partial list of some of those options.
These advantages apply if you're providing a service to users,
but what if your software is entirely internal to a given company?
Well, then you already (presumably) have access to the source code and can apply all these techniques whether the software is open source or not.
- You can have a single repository of source code containing both the code providing an API, and the code using that API,
allowing easy system-wide refactorings.
- Relatedly, you don't have to provide a
stable plugin API
to extend your system;
extensions can be maintained in that same repository and benefit from the same system-wide refactorings.
Nor do you have to support a large plugin API supporting many different kinds of changes;
users can make changes using any interface, or just fork it if they want to make changes you don't want to support.
- You can in general be less concerned with making your software runtime-configurable,
when a user is able to freely fork it to make unusual changes.
- You can ship software as source code
and let package managers handle compiling it and distributing resuable binaries for multiple platforms.
- You can ship libraries as source code
and then have the end-user run source-code-level safety-verification on that source code
to ensure that the library won't violate memory safety or access objects it's not allowed to access.
Among other things, this makes it easy to avoid the "microkernel" antipattern.
and bytecode virtual machines
are two alternatives for doing this which work for proprietary software,
but they require you to write a lot more code;
if you ship the source code, you can use the compiler you already have for verification)
- Your users can run your code,
so they can actually test against your software.
- Your dependencies can run your code as a test suite.