Helping new coders contribute to Open Source
Tags: opensource, education, github, glitch
Published: 2019-05-23 10:47:35

---
title: Helping new coders contribute to Open Source
published: true
description: Contributing to open source projects is a great way to learn and gain experience, but the barrier could be lower for new coders if we put additional supports in place.
tags: opensource, education, github, glitch
cover_image: https://user-images.githubusercontent.com/6666370/58126662-55f33f00-7c0b-11e9-9eef-d4bc52057c10.png
---

Over the past few weeks I’ve been building [an app on Glitch](https://glitch.com/edit/#!/api-learner) to help people learn a wee bit about REST APIs and make a contribution to an open source project at the same time. This is the first concrete exploration I’ve managed to make into a question that’s been bouncing around my head for a few years: could we build more supported learning pathways for contributing to open source? I wonder if this could create opportunities that might help overcome some of the barriers a lot of people encounter getting started in tech. :thinking:

# What have you got?

What often happens when you visit the contribution guidance for an open source project is something like this:
* What do you know how to do?
 * Cool, go here and do it.
* ...

![Hulk](https://user-images.githubusercontent.com/6666370/58124152-6dc7c480-7c05-11e9-8693-5a0e00d989a6.gif)

In friendlier cases there might be a link or two directing you to some external resource on how to acquire the relevant coding skills - and in lots of cases there’ll be contribution options that don’t require writing code. But the educator (and learner) in me always feels like there’s a missed opportunity here to couple contribution with code learning.

While some projects include comprehensive tutorial material on user developments within their ecosystems, it’s more commonly focused on plugins, extensions, and so on - rather than contributions to the core codebase (whether in the form of bug fixes, feature development, or whatever else). While extensible systems are great avenues for community impact, developing an extension is likely to involve less collaboration than integrating your code with an existing codebase.

![Audrey](https://user-images.githubusercontent.com/6666370/58124203-8e901a00-7c05-11e9-9883-741338633c29.gif)

I often see people (rightly imo) talk about open source contribution being a great way to learn, but [it can be a tough exercise even for experienced devs](https://dev.to/marcel_cremer/why-your-open-source-project-might-lack-my-contribution-1-4m8g), is not typically very accessible to new coders - ___and tends not to be supported as an explicit learning channel___ _(when compared with the type of educational supports we see for example in developer tool documentation)_. 

We basically have these avenues:
* Learn from dedicated education resources
* Learn by reading open source code
* Go away and acquire coding skills then come back and contribute to open source

Couldn’t we eliminate the need to go away, and instead integrate the learning with the contribution, bringing the opportunity forward for people, in some cases at least? I absolutely don’t mean to diminish the responsibility of (and debt owed to) open source maintainers, but couldn’t adding these supports be an investment in building the contributor community?

# Education vs professional software engineering

When I learned to code, the final part of my course was working on a substantial software project. Most of the code we’d written up to that point was on little standalone applications - in other words you were the sole developer working on each codebase. I inadvertently picked a project that required extending an existing system - at that point I had no idea this would present a whole different set of challenges (i.e. the first thing I had to do was fix a load of bugs :expressionless:). What I didn’t realise at the time was that this was much closer to a real-world development process - integrating my work with other people’s code.

![Buster Keaton](https://user-images.githubusercontent.com/6666370/58124441-242ba980-7c06-11e9-8542-914f635ef7fc.gif)

Over the past few years there’s been much (imo healthy) discussion around successful professional software engineering requiring a diversity of skills over and above being able to write code well. I can’t speak for all coding education programs (maybe things have changed since my course in 2006-7, hopefully not everyone had the surreal experience of writing code onto paper during exams :upside_down_face:), but it seems we’re still postponing a lot of this learning until new developers enter the workplace. 

Having worked in tech education for over a decade now, I can attest to the challenge of creating experiences that hit on a set of desired learning objectives [without being overly contrived](https://devrel.net/developer-experience/making-the-implicit-explicit) - but the reality is that a lot of our coding education is missing some of the key daily elements in working as a developer on a team. 

![Ralph](https://user-images.githubusercontent.com/6666370/58124534-5a692900-7c06-11e9-809f-27cc6b08dcfc.gif)

Some university, college, and other courses provide students with the chance to work on real-world applications, and then there are internships - __but a lot of people do not have access to this type of learning opportunity__. On the other hand, open source projects, by their very nature, involve communities - are they potential channels for people to learn both the development and collaboration / communication skills that could kick-start their resumes and help gain access to job opportunities? :trophy: :rocket: :moneybag:

![Saga](https://user-images.githubusercontent.com/6666370/58124665-a87e2c80-7c06-11e9-9141-9d1abbf3f051.gif)

# Learning and contribution pathways

OK, let’s say we try to support learning by contributing - what would this look like in practice? The honest answer is I’m not entirely sure, as it’s likely to be complex and depend largely on the specifics of individual projects. 

When it comes to facilitating learning and success with developer tools (i.e. what developer relations does), I find it helpful to define contribution pathways - how you want your community to be able to engage with your software (aside from being users).

![George](https://user-images.githubusercontent.com/6666370/58124733-d2375380-7c06-11e9-8e57-67cd71e1af4d.gif)

So what would we be trying to help people learn? What are the skills in professional software development, that are missing from traditional education models, but that open source contribution could include? 
* Collaboration
* Communication
* Code review 
* Version control 
* Anything else?

What types of resource could we use to support this learning?
* Documentation (e.g. tutorials, reference material, sample code)
* Support (of course this is a labour-intensive option, but it could also create opportunities for people associated with a project to gain mentoring experience)
* Entry points and links to existing resources creating guided pathways, potentially tailored to individual backgrounds via interactive controls
 * _This could include external resources - however it helps if a project is already well documented_ :wink:
* Community initiatives (e.g. mentoring programs, encouraging existing contributors to document their own processes, and so on)
* Anything else?

> There is a ton of fantastic generic open source guidance available (e.g. [Open Source Guides](https://opensource.guide/), [First Timers Only](https://www.firsttimersonly.com/), [Up For Grabs](https://up-for-grabs.net/), [My First PR](https://my-first-pr.github.io/)), but it tends not to be project-specific ([tutorials focusing on Git workflows](https://medium.freecodecamp.org/demystifying-open-source-contributions-c60fe2bde6d0) etc). At the project level there are some great [contribution guides](https://github.com/atom/atom/blob/master/CONTRIBUTING.md) (templates, explainers on project architecture, flagging good first issues, preferred code style etc), but I haven't come across anything comprehensive enough to function as a standalone resource walking someone through developing their contribution.

A few years back I ran a project to help people acquire the tech and collaboration skills in open source, for example by contributing to GitHub repos (that didn’t necessarily include code). I was taken aback by how intuitively people from completely non-technical backgrounds took to tools like GitHub, _so am generally optimistic about the potential of people to learn a diversity of tech-oriented skills via a single process_.

![GitHub Contributions](https://user-images.githubusercontent.com/6666370/58126662-55f33f00-7c0b-11e9-9eef-d4bc52057c10.png)

With platforms like Glitch on the rise, now seems like a great time to be ambitious about what we can help people learn. The success of future generations (and future tech) rests on the ability of everyone - to put it in Mozilla terms - to [read, write, and participate online](https://www.mozilla.org/internet-health/web-literacy/). Contributing to an open source project makes you a stakeholder - ___and with open source such an integral part of web technology, these communities should be a more authentic representation of society at large___.

# What do you think?

OK, there are certain codebases that it would be inherently difficult for new coders to contribute to, and I am certainly not saying this would be an easy learning experience to facilitate in any case - but I can’t help feeling that, if a project is designed with external contribution in mind from the beginning, it should be possible to widen the range of participants who are able to engage on that level. 

![Crucifixion](https://user-images.githubusercontent.com/6666370/58125655-f4ca6c00-7c08-11e9-9f8a-34c8327541c5.gif)

We are getting slowly better in developer education (for software products at least) at keeping the door open to less experienced learners by e.g. linking to supporting material. However, in spite of there being more code learning resources available than ever before, the software engineering barrier to entry keeps getting higher (especially with e.g. front-end web development, which used to be a much more accessible place to learn first coding skills). 

__If, as a software product owner, you take responsibility for nurturing a community that’s supportive to people new to a dev tool, why can’t we do the same for contributions to the main codebase?__

![Good Place](https://user-images.githubusercontent.com/6666370/58125706-1166a400-7c09-11e9-9f17-1e8b0b2edf7d.gif)

Working on real-world software projects took my tech skill-set up a level from the coding exercises on my course, and working on open source took me to another level again. Having initially found the prospect of working in the open extremely intimidating, in reality I found it an incredibly liberating, confidence-building experience. It also shifted my perspective on coding as a relatively isolated pursuit to something inherently team-oriented (and to my surprise I loved that aspect of it :joy:). I wish we could give more people that sense of what collaborative work software development can be.

___I’d love to know what people think about this approach? Have you tried it already? If you think it would be too problematic to implement in practice, well, you might be right, but having been consistently amazed by learners, I genuinely believe it's worth exploring!___ :pray: :mega: