Skip to content
Switch branches/tags

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

This is the transcript of a talk I've given on June 27, 2019 at React Vancouver Meetup.

The talk was inspired by an article I published earlier: Learn by Contributing


Learn by Contributing - React Vancouver Edition


Since the beginning of my professional career, I was always curious about the people standing behind the tools I use to get my job done.

As an example, let's take Babel - the famous transpiling framework, or Webpack, or even ReactJS itself.

It took me a while to understand how these tools work, they were like a magic! And the people behind those tools seemed wizards!

The impact of these technologies is tremendous!

Almost every JS developer uses at least one of these tools every day.

How many amazing products and businesses, that help millions of people are powered by these technologies?!

But, no one is born a "wizard", right?

It takes tiny, incremental steps and hard day-to-day work to master a skill. It takes many trials and attempts to build a successful project.

Aslo, it is extremely important to have the right and supportive environment. Environment that allows you to learn, test you assumptions, and get a quick feedback. We are lucky to have such an environment.

The world of front-end JS development is a welcoming, open environment - open for learning, for creativity and collaboration.

Almost all the tools we are using in our day-to-day professional life are

  • free
  • accessible
  • open-source tools!

Contributing to those tools is a great way to learn, improve your skills... and become a better developer!

Let's see what benefits do you get from contributing to open source software.

Projects of excellent quality

Open source software is not an underdog anymore.

The quality of code is often superb to internal codebases. By working on such projects you see how others do a good software.

You're creating a proof of your expertise

Having an impressive portfolio on Github (or whatever platform of your choice) is a solid indicator for your future employer.

Many headhunters use Github to find talents.

Let's say you are not good with whiteboard interviews or not familiar with the technology used by your potential employer.

Having your contributions can help a hiring manager to evaluate your skills and professionalism.

Some companies hire core contributors, that work on company-supported open source projects.

Glimpse into professional software development

You can see and learn how software is done at

  • Microsoft
  • Google
  • Facebook

or many other companies that are known for good engineering.

While working on such kind of projects, you adopt the coding practices, receive feedback employees - it's like having a personal mentor!

Create a professional network and opportunities

It is a great feeling to know that you're part of something bigger - that there's a community of like-minded people that appreciate your work and share your ideas.

While working on open source, you collaborate and create a network of professional contacts.

It creates opportunities for collaboration, employment opportunities, ideas for side projects and businesses.

For professional developers and seniors

I imagine that some of the listeners would say that Open source is not for them. It does not have the complexity or scale of problems that they deal with. It seems like a waste of time!

So, probably yes, but I believe, you still can learn a lot from OSS.

Even if you have "senior" title on your LinkedIn profile and feel strong about your current position, you'd never stop learning.

You never know how much you don't know!

Let's take a look for a second at how do we learn; how do we acquire a skill:

  • you learn something
  • you do
  • you get feedback
  • repeat

For senior engineers the feedback loop is very long.

Let's say you've implemented a new architecture or created a cool abstraction.

Is your abstraction leaking? Is your architecture scalable? Does it hold a smallest change in requirements?

Often it takes months until you get validation of your initial assumptions. Without this feedback how do you know if your idea was great, or you probably should have tried another approach?

Contributing to open source might be way to validate your seniority.

Popular projects have large user-base and a lot of experienced contributors, they don't care about your title. You will get feedback quickly - if your ideas are great, they will be recognized.

How to start contributing

It is hard to start contributing without any context or motivation.

There's a lot of space for improvement for JS tools - every time you see a problem - no matter if it is:

  • documentation
  • missing types definitions
  • a bug
  • an enhancement

consider it as an opportunity to improve and to learn.

Even when you don't have time, and decide just to report an issue, you still learning something!

It's quite hard to describe a problem precisely in a few sentences. While trying to compile an issue into a reasonable explanation, you can realize that it wasn't problem with the tools at all.

While creating a reproducible example, you can realize what could be a solution or workaround.

While submitting an issue, you might discover similar open issues and suggested solutions or workarounds

Once submitted, your issue will be helpful for other developers

How to get the most value of you contributions

Supporting tools

The most value you’ll get is when you decide to get your hands dirty, check out the code and submit a pull request with a fix.

When you start to explore the new project you’d pay attention not only to the code itself, but also to how the project is organized.

What other tools are used to support the project?

I have tried to create a list of tools that I've managed to explore while working on open source project:

  • Sub-packaging

    • lerna
    • yarn workspaces
  • Supersets

    • Typescript
    • Flow
    • Coffescript
  • Build process and tooling

    • Webpack
    • Rollup
    • Parcel
  • Automation tools

    • Grunt
    • Gulp.js
    • Makefiles
  • Issues management and classification

  • Project structure and organization

    • Components
    • Configuration
    • Documentation
    • Type Definitions
  • Code Quality controls tools

    • eslint
    • husky
    • bundlesize
  • Testing frameworks

    • Mocha
    • Jest
    • Ava
  • CI pipelines

    • Travis CI
    • Circle CI
    • Jenkins
    • Gitlab
  • Project structure and code organization.

Testing and CI

Most successful open source projects have an excellent testing strategy and a pretty good CI pipeline.

By contributing to different projects, you can learn different ways to:

  • organize tests
  • create mocks
  • use of fixtures
  • unit and integration tests separation

You notice the good parts and the bad parts and next time you work on your project you know what to avoid and what to preserve.

Reading and modifying code

When you get your hands dirty and start to dig into a new codebase, you discover new coding techniques - it might be:

  • new coding style you weren't aware about
  • usage of language features you didn't know about
  • abstractions that make code flexible and elegant

You are starting to see and touch more stuff and different stuff.

That’s how you get experience; that's what makes you more valuable, more experienced professional.

You start to realize how tools work internally. You start to understand how the "magic" works!


To summarize, I encourage you to do a small, tiny step towards becoming a "wizard", today!

All you need is a bit of patience, a laptop and a Github account.


The transcript of a talk I've given on June 27, 2019 at React Vancouver Meetup.







No releases published


No packages published