Click here to Skip to main content
13,254,366 members (56,776 online)
Click here to Skip to main content
Add your own
alternative version

Tagged as

Stats

5K views
6 bookmarked
Posted 28 Apr 2017

Contributing to .NET for Dummies

, 28 Apr 2017
Rate this:
Please Sign up or sign in to vote.
Contributing to .NET for dummies

Contributing to .NET for Dummies

Over the past few months in the little spare time that I have, I've managed to submit a handful of pull requests to various .NET-related repositories (e.g. coreclr, corefx, docs, etc.) and incredibly, they were accepted.

Now, for some, this may not seem like a big deal. But it felt like a pretty big one to me so I thought I would take some time to elaborate on the process itself, share my experience, and hopefully dispel a few myths or misconceptions that you might have that may be holding you back from contributing to .NET as well.

Hopefully, you'll find that you don't need to be a genius or design a better sorting algorithm to make a meaningful contribution to .NET as a whole.

Dispelling Some Myths and Preconceived Notions

I'll openly admit that before browsing through the available dotnet repositories, I was seriously intimidated, but without any real justified reasons. It seemed that I had built up quite a few myths surrounding the projects that were probably holding me back from contributing, such as:

  • I need to be a coding wizard and all of the open issues are out of my reach.
  • All of the easy issues that I could handle are taken.
  • Since this was all in the open, I will be exposed as a crap developer (see Impostor Syndrome).
  • I've never worked on a project of this scale, I'll probably screw it up.

These were just a few of the things that I had mentally told myself before embarking on this journey. What I quickly found out: none of these things were true.

Let's tackle each of them, shall we?

Myth #1: I need to be a coding wizard and all of the open issues are out of my reach.

Contributing to .NET for Dummies

All is the key word here.

There are a TON of 'up-for-grabs' issues available across all of the dotnet repositories. Some of these are serious challenges that require significant dedications of time, effort, talent, and thought. These feats aren't generally tackled alone, and undergo rounds of feedback and critique from both the .NET team and the community.

For each of those wizard-level problems, there are countless other housekeeping related ones that most developers could tackle. The best part about these, is that they usually only need a bit of elbow grease.

Let's take a glance at my first contribution to a .NET-related repository.

This wasn't an open issue, but one that I stumbled upon when reading through the docs one day. I noticed that several variables throughout the examples had the following format, which just looked odd:

// static public doesn't look right, does it?
static public Type Foo { get; set; }  

This directly goes against the .NET Framework Coding Guidelines, which state that "the visibility modifier should always be the first modifier present". This meant I just needed to cull through the repository and find any other instances of this discrepancy and change the previous examples to:

// Ah! Much better!
public static Type Foo { get; set; }  

That's it!

I didn't have to invent a new algorithm, reduce any allocations, or anything. It's housekeeping, but it's something that needs to be done and does make a difference in the long run.

The entire process took place over a lunch break. I forked the repository, made the changes, submitted the PR, and it was merged all within a matter of hours. What a great feeling!

Myth #2: All of the easy issues that I could handle are taken.

Contributing to .NET for Dummies

The low-hanging fruit is often the quickest to be picked, and GitHub issues are no exception.

A while back, it may have been tough to find an "easy" issue to get your feet wet before it was snatched up. This isn't really the case anymore as the .NET folks have created a simple way to find your first issue to work on: the 'easy' label.

The 'easy' label is generally reserved for first-time contributors to the framework and it allows them to get their feet wet.

If there's an issue that you want to work on, simply jump in and ask to be assigned to it, and then you can get started. The .NET team members are incredibly helpful at answering questions, and generally don't mind walking you through the process.

So if you want to contribute, consider going to one of the popular .NET-related repositories and searching for the following under the Issues area:

is:issue is:open label:easy label:up-for-grabs 

This will filter all of the available issues that are currently opened and designated as "beginner friendly" (i.e., they are both up for grabs and should be fairly easy):

Contributing to .NET for Dummies

The general rule of thumb has been to reserve many of these types of issues for first time contributors, so this is probably a great starting point if you want to dive in.

There are more and more added each day, but they do tend to go fast. So you may want to keep an eye out for something that piques your interest, and stake your claim when you get the chance.

Myth #3: Since this was all in the open, I will be exposed as a crap developer.

Contributing to .NET for Dummies

If you have done anything related to open-source, you can probably skip this section as you already know what it feels like to have your code viewed by potentially hundreds of thousands of people a day.

If you don't, then you might be a little nervous. You might not be incredibly familiar with the process, the code base, or even things like git. Or you just might be afraid that people will judge and criticize your code to the point of embarrassment.

Well, don't be.

I know that's easy to say, but everyone that you will be working with throughout the process is there to help you (i.e., you are not going to be alone during this process).

Each of the major repositories has more documentation that you could imagine a wide range of topics such as:

The documentation will vary depending on which repository you are in and they are probably better documented that most projects you may have worked on, so that should ease some of the tension.

Once you actually submit a PR, a team member will review your commits and provide any feedback, which I've found to be a fairly pleasant experience. You might have a few nits here and there with minor changes or the reviewer may offer alternative approaches or recommendations to solving the problem (this commonly occurs in areas involving performance).

In my personal experience, the team was always extremely quick to react, and I felt that we were always on the same page and working together as opposed to them simply critiquing my code.

Myth #4: I've never worked on a project of this scale, I'll probably screw it up.

Contributing to .NET for Dummies

Firstly, let's get this out of the way: some of these projects are huge, and likely way larger than most things that you have probably encountered before. As such, you are going to need to work with them a bit differently.

When I first forked projects like the coreclr and corefx, I will admit that they were a bit intimidating. Due to their sheer size and scale, they aren't terribly Visual Studio friendly, at least from a building and testing perspective. Thankfully, there should be documentation for how to go about building these within each of the repositories.

Basically, you'll need to become acquainted with running the available building and test scripts from the command line. After building the projects, you should be able to open them up and edit them using Visual Studio, but keep that command prompt open as you'll use it frequently.

Testing and debugging are also going to be done predominately from the command-line as Visual Studio's Test Explorer will melt if it tried to run all of these tests. Thankfully, there's extensive documentation for that as well.

Getting acclimated to this environment can probably be one of the largest learning curves in this entire process, but it's something that you'll only need to do once. Another thing worth noting is that due to the scale of these projects, building can be slow, so make sure you have something to do while you wait.

How to Contribute

Hopefully, the dispelling of some of these myths might have built your confidence up enough to consider making a contribution. If so, here's what you'll need to do:

  1. Find an issue that you want to work on. Consider either searching one of the popular dotnet repositories using the easy/up-for-grabs labels as mentioned earlier, or try out an aggregate site like Up For Grabs.
  2. Sign a Contribution License Agreement. In order to work and actively contribute to a .NET Foundation project, you'll need to agree to the terms of the CLA. This will also require you to set up two-factor authentication for your GitHub account.
  3. Fork the Repository. In order to work on a particular issue, you'll need to be working on your own fork of the project, which you'll eventually merge back in once your changes are complete.
  4. Building and Running. I'll go over this a bit within the next section, as it isn't likely going to be the same as running your average project within Visual Studio.
  5. Make Your Changes. After you have the solution running, make your changes to apply the fix. Don't be afraid to ask any questions on GitHub if they arise throughout this process.
  6. Write Tests (As Needed). Some changes will require that a set of unit tests are written for any new or altered functionality. Any team member that is assigned to your issue will likely let you know about this, and about where to go about writing the tests themselves.
  7. Submit Your Pull Request. Now that all of your changes are made and they appear to be working, you can submit your pull request. It will undergo a review process and a team member will provide any feedback as needed.
  8. LGTM! "Looks good to me!" This will usually be one of the last things that you see on your PR, and it's an indication that you are about to officially become a contributor to .NET. Congrats!

In Closing

My experiences with contributing to .NET have been nothing but stellar. It was great to have a chance to collaborate with members of the .NET team and the community towards improving the ecosystem, even in the smallest of ways. Simply knowing how a minor performance improvement that saves milliseconds here or there could save so much time on such a large scale is really rewarding.

I know that this experience certainly struck a chord with me, and in the weeks following my initial merged pull request, I've probably rattled off 10+ additional ones, and I look forward to contributing more in the future.

I hope that this post helped ease your mind if you thought that you wouldn't have anything to contribute, or that it would simply be beyond your skill-set or talent. There's something out there for everyone, so go out there and get that First-Time Contributor badge and help make .NET a better place.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Rion Williams
Software Developer (Senior)
United States United States
An experienced Software Developer and Graphic Designer with an extensive knowledge of object-oriented programming, software architecture, design methodologies and database design principles. Specializing in Microsoft Technologies and focused on leveraging a strong technical background and a creative skill-set to create meaningful and successful applications.

Well versed in all aspects of the software development life-cycle and passionate about embracing emerging development technologies and standards, building intuitive interfaces and providing clean, maintainable solutions for even the most complex of problems.

You may also be interested in...

Comments and Discussions

 
Questiongood one Pin
prao20162-May-17 16:45
memberprao20162-May-17 16:45 
GeneralMy vote of 5 Pin
dmjm-h1-May-17 12:27
memberdmjm-h1-May-17 12:27 
GeneralMy vote of 5 Pin
AJSON1-May-17 2:37
mvpAJSON1-May-17 2:37 
GeneralMy vote of 5 Pin
UlysseEstienne29-Apr-17 1:27
memberUlysseEstienne29-Apr-17 1:27 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web02 | 2.8.171114.1 | Last Updated 28 Apr 2017
Article Copyright 2017 by Rion Williams
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid