At Dwolla, we are believers in the power of open source software.
We believe that using and contributing to open source makes for better designed and safer software, enabling developers to focus on building tools and writing code that are within their specific area of expertise.
When developing open source software, there are some guiding principles we believe in and can share with you, but first let me provide some background.
Value of Open Source
Open source software has helped drive much of the growth and innovation on the internet in the last few decades.
It allows for all companies—or even a couple of developers in their garage—to start from a base of software that is free to use, modify, and experiment with. They aren’t tasked with becoming experts in operating systems or network communication; instead, they can focus on the company they want to build and getting to market much sooner.
With open source software, those same developers also know the software or code they are using has been reviewed by their peers, the greater community of developers.
Better yet, if they have any questions, they can see the source code for themselves and make any changes they need. This can lead to software that is safer and stronger and gives more power to small companies and independent developers.
Contributing to open source projects
Recently, Dwolla was part of the team contributing to Mojaloop—the Gates Foundation’s open sourced software for creating interoperable payments platforms.
As part of this project, we worked on a project designed to be open sourced from the beginning. This was an exciting opportunity to build something that could potentially be a foundation for payments in developing countries and ecosystems and to see how it could grow and change from where we started.
Building software that you know will be completely open sourced calls for a slightly different set of priorities. We knew this code was going to be openly available, so there were a few principles to consider that are different than working on closed source software.
Principles to Consider
First, you have to remember that there will be people using the software that wasn’t part of the original project. This means that you can’t assume they know anything, and you have to document, document, and document some more. You must have clear documentation of the software, including what it does, dependencies it requires, and any configuration options that are present.
While working on Mojaloop, we took these principles to heart. All of the individual initiatives have helpful documentation, including README files, API documentation, example projects, and “getting started” guides.
Providing examples of the software in use is also a great addition. Examples help developers understand how the software is intended to be used, while also providing an excellent place to start with their usage of the open source code.
A project with an extensive set of examples would be Chefspec. Here, developers can find real-world examples of tests you may write for Chef recipes. These real-world examples can serve as foundational starting points.
Create a Roadmap
You should also create a roadmap for the project since the initial open sourcing of a project is rarely the end state. The project will continue to grow and attract users and volunteers; providing a roadmap gives volunteers an idea of what features can be contributed to. A roadmap not only gives others a chance to see what is coming for the project but also encourages feedback and ideas on how to evolve the software.
A great example of a project with a clear roadmap is Mozilla’s Firefox. This roadmap does an excellent job of highlighting the focus of the project for the year, while also giving target dates and build numbers for when features will be available.
Document Architectural Decisions
In working on Mojaloop, we also documented many of the architectural decisions that were made, allowing those who might be new to the project to understand some of the questions and considerations we thought about and discussed during the initial development.
We also created a roadmap that clearly outlines what features need further development and some larger features we would love to see the software support in the future.
In open sourcing, the software you create has the potential to be used by many people in a wide variety of ways, so it’s important to consider extensibility. From the beginning, you have no way of knowing how others will want to use it or what they will specifically want to do with your open source code.
By designing your software to be extensible, you make it easier for users to adapt it for their projects. Extensibility can also allow for people who are less technical in nature to modify the software through plugins or other options for adding features. WordPress’s fantastic plugin support is a great example of this extensibility.
During the development process, we decided that extensibility was going to be a main feature of Mojaloop’s Central Directory.
Serving as a core component, the Central Directory allows a user to be found via search through many different pieces of information. There are endless ways to search for someone, from their name to their email address, to their Facebook account. Rather than designing the Central Directory to store all of this information for a user, we wanted to leverage systems that were already securely storing this data and apply it to search.
The Central Directory allows for an expanse of systems to be easily plugged in, so that those integrating the open source project can be found quickly and with no personal data requirements.
Mojaloop & Open Source
Mojaloop was a worthwhile project that allowed the team at Dwolla to really get involved with and contribute to open source software at a deeper level.
Open source is something that we use and contribute to regularly, and we believe it is one of the things that helps make it easier and safer to build new and exciting platforms, applications, or infrastructures.
Looking to the future, technology will only continue to become more collaborative and transparent. Open source projects are great examples of giving back to the larger community, allowing those who are experts in specific areas to share their knowledge and perspective and ultimately enabling better collaboration.