Together with a few colleagues we met for a brainstorming session. The goals set for this session were:
- Share experiences about open source contribution at Liip and together with customers
- Reflect on added value we can generate when contributing to Open Source
- Mention any blockers, uncertainties or difficulties that you encounter when it comes to Open Source contribution
- Come up with ways of including Open Source contribution into our workflows
- Brainstorm what our customers would find valuable to know about Open Source contribution
In our check-in, we asked which topics attracted people to come to the workshop. We had a good mix of engineers, product owners and UX folks from Drupal and Symfony in our meeting. The topics of interest spanned from “motivating clients to pay to create reusable solutions”, “sharing experiences in the context of contributions”, “getting started with contributions in 2021”, “listening in”, “finding ways to giving back”.
The canvas allowed us to capture different aspects of adopting contribution practices by asking structured questions:
- Triggering Event - What were those events that led to your decision to contribute back to Open Source?
- Desired Outcome - What outcome were you looking for?
- Old Solution - What solution were you using that was already in place?
- Consideration Set - What were alternative solutions that were considered?
- New Solution - What solution was selected? Why?
- Inertia - What were some concerns/anxieties you had before starting to contribute?
- Friction - What were some concerns after you started contributing?
- Actual Outcome - What was the actual outcome after starting to contribute? Did it meet your expectations?
- Next Summit - What would you like to see next for contribution? Why?
Examples mentioned were finding issues in existing Open Source solutions. Another key triggering event was that when the client understood how
Open Source works, they would be much more motivated to fund contributions. Often it is the motivation by an individual or the team striving to create better solutions without the need to maintain custom code individually for a customer project.
Goals we are striving for when contributing to Open Source include externalizing maintenance efforts to the community at large as well as doing good. By contributing back we are fueling the ecosystem that keeps our software up to date and innovative. We create more sustainable solutions when we are able to use standardized building blocks and follow community best practices.
When facing contribution opportunities, we are often presented with various ways to solve the issue. Fix the issue in custom code (miss the chance of contribution), fix the issue in a contributed module or fix the issue in Drupal core. Depending on the layer of abstraction, we can shoot for quick solutions or spend more time working on a generic solution. Alternatives to fixing the issues ourselves also include that we sponsor other maintainers to work on a sustainable solution that includes the resolution of the current issue.
We have also encountered issues where relying on too much abstract code created a risk for the project over time, especially when you deviate from the standard components it might become easier to internalize the functionality into the custom project’s code base so that it can be adapted without context switching but at the cost of needing to maintain the functionality without community support.
Even non-perfect code or work-in-progress can be released as Open Source so that others are able to build on it and eventually these building blocks will be further evolved. Sandbox projects or alpha releases can serve well as incubators for contributed code. Over time, when the project gets more mature, the semantic versioning approach with alpha & beta releases allows to specify well what users of the module can expect.
When discussing what was holding us back from contributing, many reasons can apply. Contributing to Drupal core takes more time than writing custom code. Sometimes it is just that folks involved don’t understand how Open Source works or what it is good for. When we create quick & dirty solutions, we sometimes don’t feel quite ready to Open Source them. Sometimes, we just don’t feel a need to contribute back because we can achieve our short term goals without doing so. Family folks mentioned that they can’t commit private time and focus on getting the job done during work time.
When discussing what was holding us back when making a contribution, we found that sometimes the effort invested doesn’t match the outcome. We need to invest more time than what we think is worth solving the problem. This can be especially driven by the fact that contributed code may imply higher quality standards enforced by peer-review from the community. It’s also the urge that once a solution is Open Source, we feel like we need to maintain it and invest more time continuously. If a custom solution is cheaper, why should the client pay for it when they cannot reuse it themselves? Sometimes we are not certain if anyone else will be willing to make use of our custom code.
We talked about the benefits that folks got when adopting contribution was adopted as a practise. Getting good community feedback on their solutions, having their solutions improved and evolved further so that it matches new use cases was mentioned. Giving speeches at conferences is also something that was found to be valuable. As a new step for contribution, folks mentioned that they would like to get help pushing their contributed modules so that they get adopted by a wider audience.
We also identified some USPs (Unique Selling Proposition) for contribution during the discussion. Clients would not need to pay for improvements contributed by the community. The maintenance of solutions based on contribution becomes more reliable. Contribution elevated self-esteem for clients and teams and helped increase visibility. It helps as a sales argument for agencies towards clients and also helps engineers to become hired by a Drupal agency like Liip. Some folks even manage to make money on platforms like GitHub sponsors or Open Collective.
We closed our meeting to collect some takeaways and what’s next for folks in contribution. Here’s a list of the key takeaways:
- A “contrib-first approach” that incorporates the contribution mindset
- Adding contribution checkpoints into the definition of ready/done
- Inviting for cross-community contribution between Symfony and Drupal
- Raising contribution in daily meetings, motivating each other to speak at conferences
- Making sure that our contributions are used by others
- Helping to find areas of contribution for non-developers
- Balancing being a taker vs. a maker
- Evolving a plan to communicate our efforts around contribution
What’s next for you in contribution? Have you experimented with the Customer Forces Canvas? Thank you for improving Open Source & let us know in the comments.
Image credit: Customer Forces Canvas (c) LEANSTACK