How To Contribute To Open Source Without Being a Programming Rock Star
Esther Schindler writes "Plenty of people want to get involved in open source, but don't know where to start. In this article, Andy Lester lists several ways to help out even if you lack confidence in your technical chops. Here are a couple of his suggestions: 'Maintenance of code and the systems surrounding the code often are neglected in the rush to create new features and to fix bugs. Look to these areas as an easy way to get your foot into a project.
Most projects have a publicly visible trouble ticket system, linked from the front page of the project’s website and included in the documentation. It’s the primary conduit of communication between the users and the developers. Keeping it current is a great way to help the project. You may need to get special permissions in the ticketing system, which most project leaders will be glad to give you when you say you want to help clean up the tickets.'"
What's your favorite low-profile way to contribute?
Documentation.... This is the most needed thing in open source.
No good deed goes unpunished.
Especially bugs that the developer sees as not worth fixing, and the solution is to simply not use that feature.
Glad I could help.
GSoC (20% acceptance, considering the low SNR on applications, someone serious has a good chance)
Also, KDE SoC and Openhatch
And probably many others I dont know about
I think the most important thing is to contribute to something you use and like. That’s how it is supposed to work. You add features / fix bugs that effect you, and everyone else benefits as well! Ever use a program and think “damn, I wish I could do whatever>”. That’s a good place to start.
The article touched on IRC and mailing lists, but I think it’s worth adding that a period of “just hanging out” is usually a good idea before going into contributor mode. Let people get to know you. Get to know the main people. Maybe it’s a den of politics that you don’t want any part of!
When you are ready to contribute something... I think it’s a good idea to ask in the channel/mailing list first. Maybe someone is already working on something similar. Maybe they have discussed the change before and decided against it. At the very least, it creates a kind of expectation that when you are done, it won’t just be ignored.
Not really low profile way to contribute just general advice.
Also, big time on sticking in the channel and helping other people out.
I have a few linodes around that 99% of the time have plenty of spare bandwidth, so I will typically start seeding the torrents when a new release hits, even of a distro I don't use, and I'll upload 25gb or so.
Don't blame me, I voted for Kodos
Localization is always needed, either correcting, improving or adding translations for an open source project.
Doing themes, skins, plugins, macros, whatever is around it that is not specifically programming and could need less or different skills than programming.
Also actually using it and being vocal about that fact, the social component make people aware that exist that software, that have users that you know, and that there is a point of contact with the community behind it.
Documentation, and everything around documentation (i.e. putting in your blog or in a comment how to do x with that software)
There are lots of platforms and the developers might not have access to all combinations of hardware and compilers. It's always good to hear about tests of new releases even (especially) if it's simple "works for me" on such-and-such platform.
Report bugs you find with detail, and any errors you receive, what you were doing when you received the error, etc. Enable automatic bug reporting if the program has such a feature.
If there was a bug, someone would fix it. Therefore Open Source does not have bugs. This article is Microsoft FUD.
Well, if you're a programmer feeling like you may not be a programming rockstar and are afraid to contribute... consider that most projects are not written by programming rockstars either. The codebases might be large and intimidating because people have put in a lot of time getting lots of things to work, but it's often packed with cases of, "it's good enough for now". And that's not necessarily a bad thing, it keeps things moving forward.
I know Steve Jobs isn't the right character to invoke here, but he once said:
Once you discover one simple fact; and that is everything around you that you call life was made up by people that were no smarter than you. And you can change it, you can influence it, you can build your own things that other people can use. Once you learn that, you'll never be the same again.
I lean on that from time to time, and it's usually right. The only trick is knowing when it's wrong. ;)
Speaking as someone who contributes to PostgreSQL, one of the projects mentioned in TFA, the easiest way to contribute something useful to that project while having some fun too is to test out new features. Reviewing a patch that hasn't been committed yet is part of the community process for validating what features get committed. And testing recently committed features is useful too, to help flush out bugs in them before release. Working on new features seems to be more attractive to new contributors than trying to fix old problems, and good reviewing skills flow naturally into becoming a code contributor too.
-Can't even think of contributing to OpenOffice or Gnome, since just setting up the build environments for those is highly complex, I've heard.
-Huge amount of time to build and test those programs.
-I'm afraid of what setting up the dev libraries would do to my normal environment I use for normal work.
-Requires a hugely powerful machine, whereas some of us like to work on a less-powerful, smaller, portable laptop.
I'm not a lawyer, but I play one on the Internet. Blog
Um... I guess you haven't seen much open source code... Rock stars are definately not required.
Post inane drivel in the name of OPEN SOURCE. Oh wait, that's how not to do it.
Fandroids hate facts.
I had written a Python script consisting of about a couple of hundred lines of code (including comments) for a task I do on a regular basis. I've been meaning to add features to it but haven't touched the code for over a year because to be honest, although I had structured it into proper functions/procedures only doing one task and group similar code into packages and had commented it, it was still a bit of a mess.
I recently stumbled upon the Unix philosophy and it gave me a different perspective on how to program. I think the biggest eye-opener for me was the concept of connecting a number of small programs via streams to make larger programs. I've done this many times by for instance by piping the contents of find through grep to find a piece of text in a number of files but it did not occur to me that this could be used in programming. The implication is that rather than writing a lot of code, it could be easily done in a lot less lines by calling an existing program and putting the output into a data structure to be used by the program.
I've been googling more about the Unix philosophy and I have tried to apply it to the Python script I had written. The things that stood out was writing a program that did one thing well and prototyping to get the program working then refining afterwards. I've had a look at my code and see a lot of functions and procedures that do a number of tasks. An example of this was one that was extracting data from a data structure and putting it into a pyGTK treestore. I had separated this and redesigned a new function to extract the data so that it outputs text to the function that puts it into the one which populates the pyGtk TreeStore. A useful thing about this is that it is easier to pull the code from this and insert it into other programs if I wish. As well as this, I am looking at other ways to make the code easier to debug and to add extra functionality.
I think a lot of the Unix philosophy is common sense and I'm sure it is second nature to experienced programmers but to casual coders like myself, it is a number of guidelines that points me in the right direction.
Obviously some users need support.
If you are good at troubleshooting, this is the way to go.
Good troubleshooting has also value for the programming rockstars.
Your resume is a document that shows what you have done, and backs up your assertion that you're qualified to do the stuff you've applied for. What you're paid -- or whether you are paid -- is not relevant. Accomplishments are.
My biggest issue with Open Source is bug replication and bug report management. By the time I get to use a software and it has made it's way into the Ubuntu repositories it is already a few month old. Bug reports on that software in turn are often of limited use as a newer version might already fix the issue. The problem is that going through all the trouble of actually getting a new version, all the dependency, getting it compiled and setup is rarely practical. Thus a lot of bug reports end up hanging in the Ubuntu bug tracker, as nobody is going to spend time on checking that the issue still exist upstream and then reporting the issue to upstream, maybe including a better test case then found in the original report.
So simply put: If you want to help, act as a mediator between the developer and the user. Browse the bugtrackers and forums for problems users have, replicate them and check that those issues still exist. Then provide test cases or fixes for those issues to upstream and workarounds to the users.
Many of the suggestions listed will work for closed source - which you may not want to do for philosophical reasons, but go towards improving it for every one.
Designing and building installers. It's something many programmers hate to do, and it's so critical to the success of the project. If installation doesn't go smoothly, many people will just stop there and never start using the program. It's also quite challenging, given all the subtle differences you encounter between different OS versions and even individual computers.
"I'm too busy to research this and form an educated opinion, but I do have time to tell everyone my uninformed opinion."
I'm a sysadmin and totally not a coder. But I'm also a writer. So
1. Install it on stuff. In particular, install it on platforms that aren't Fedora or Ubuntu. Document problems you find. Cross-platform = robust.
2. Documentation, FAQs. The documentation always lags. 1. will generate lots of stuff you write up. Wikis can always do with maintainers too.
http://rocknerd.co.uk
Many open-source projects need more than just programmers. If you have an artistic bent, whether it's musical or with actual artwork, look around and see if there are any open-source games that require input.
In my case, I contributed (as 'Pangloss') to an open-source remake and update of 'Elite' (the first open-ended 3D space trading and combat game) called Oolite. Once you learn a few things about the game, you start posting hints and tips for other people on the forum and before you know it you're getting involved in multi-participant submissions and developing planets like you're Slartibartfast...
Shiny. Let's be bad guys...
A recent /. story discussed the bookOpen Advice which is about finding ways to contribute. It's worth reading.
Just wanted to add that I wrote a very similar article 8 years ago: ContributingToFOSS.
I know I'm far from the first to say it, but write docs. Here's how.
cheers
I have recently started a project, http://www.pmsapp.org and I am doing everything I can to get people to follow the project and help out.
I have fairly active bloggers blogging about the project, I am tweeting about it and I have it listed on freecode.
So far, a single person has offered to help, which is great, but a lot more help is needed to get the project flying.
Am I simply not doing enough updates on the project or is there something I have missed?
With regards to the ticketing system - if someone posts a ticket for a problem, see if you can reproduce the problem with their particular version. See if the problem still exists in the head of the latest code trunk. See if the problem is a duplicate of another problem. See if the problem is with the program, or somewhere upstream, say, a library that the program depends on. If so, report the problem upstream.
Core developers are busy, and most projects can use people who deal with and clean up tickets, leaving only real problem tickets to deal with. Also, sometimes a program or library from Gnome or freedesktop.org will have tickets in the trouble ticket systems of Debian, Ubuntu, Fedora, SLES, Gentoo etc. Someone doing a little coordination will be helpful.
The thing is, even top notch programmers unfamiliar with a large program are initially at a disadvantage to a middling programmer who is well-familiar with a large program. Everyone is initially at a disadvantage when a program breaks, no matter what the skill level. But even if your programming skill level is very low, most projects can benefit from extra help. Even if you just confirm a bug exists on your system too, or that you can't reproduce a bug - this helps core developers save time.
A group of FOSS developers and faculty interested in FOSS brainstormed a list of ways
that people (especially students) could get involved in FOSS projects.
http://xcitegroup.org/softhum/doku.php?id=f:50ways
"What's your favorite low-profile way to contribute?" Well, since you're asking...
Something that's been on my "todo" list for ages is to volunteer to maintain some of the modules in the core perl library. That's something that any solid perl programmer ought to be able to help with (even if your C skills aren't well tuned-up at present), and I've been told that there's a shortage of people willing to do it.
Writing documentation is a great idea too, of course, but while the perl docs can always use some work, they're actually pretty good compared to some other projects. Perl programmers seem to like to write things down.
Andy Lester himself is famous for being willing to write test code. That's a good way to go, of course: there are still some big projects out there that barely have any tests.
Not every project has their own hosting, can host everything (proprietary files which need to be included, but can't be directly due to licensing), or are too big for common hosts like SourceForge. If you've got a bit of spare bandwidth, why not offer up a public mirror for them to use?
I sometimes spend time answering questions at the Firefox support forum.
It is one of the easiest ways of contributing to the open source browser without having to dig into its code.
Being a regular user of the browser, I am already familiar with most of its features and options. So, the learning curve is pretty easy.
Even answering fairly "low-hanging fruits" like this one can be a pretty rewarding feeling.
On top of that, you get to closely observe the diverse ways in which real end-users interact with a software application. IMO, this is an invaluable experience and insight for any programmer developing any kind of application.
Maintenance of code and the systems surrounding the code often are neglected in the rush to create new features and to fix bugs. Look to these areas as an easy way to get your foot into a project. Most projects have a publicly visible trouble ticket system
Maintenance of the code IS bug fixing, or adding a new feature to old code. From a programming standpoint, what else is there? What is in your trouble ticket system that is NOT a bug of a new feature?
I am no great programmer, but I am usually good pretty good at following logic in code. I can usually tweak a little code here and there to get the desired result. Many times, bugs in code comes from typos and / or poor documentation in the code. Pretty much, anyone with a year or two of programming in school can do some simple debugging.
Back in my Linux days, I helped with some of the early DVD software code. This was the days before DeCSS, so we were working on getting drivers and software working for a hardware decoder (for the life of me, I can't remember what it was called, but I think it was made by Creative Labs). Anyways, other people had gotten most of the functionality working, but there were bugs in things such as Subtitle colors and positioning, being able to read multi-angle discs, and being able to read chapters on a disc. The code was there, but some was commented out because it had bugs in it, some had the code but was improperly implementing it, etc. I just played around with the code for a couple of days, fixed the issue, and submitted my patch back to the community. And I learned a lot about how DVD actually worked.
Granted, I couldn't write a GUI to save my life, databases scare me, and I don't know many of the newer languages. But tackling a bug here and there is usually not as hard as one might think. You don't have to go through ten million lines of code, just work on a couple of hundred lines for a menu or an event or something. Play with it and see what happens. Once you learn how it works, then you can start working on bugs. And put comments left and right in the code, so that others can easily code as well.
Two thoughts:
1) check out FLOSS Manuals for creating documentation in a collaborative way
2) contribute to open source and do social good at the same time, check out http://socialcoding4good.org
ColdFusion: There's a commercial version (Adobe's) and open source version that almost exactly the same (Railo). (There's also another open source version, Open BlueDragon, but it has diverged enough away from the original version that it's not a good comparison - but honestly I feel OpenBD docs are the best of the 3)
I won't say the Adobe documentation is great, but it is very complete, with every tag and function fully documented. Railo, however, has a loosely organized wiki, with semi-complete docs for 3.1 and 3.2, and a few articles related to 3.3 features - so unorganized and disjointed. Yeah, you can dig around on blogs and Stack Overflow, but saying it's "community supported" really doesn't cut it when you need to find a solid answer. Hell, most of the time when working on a Railo project I'll jump over to Adobe's documentation and hope that it's 100% compatible (most of the time it is).
That said, I think Railo is a great and in many ways superior product, especially in terms of performance and a few innovations, so I'm not bad mouthing as much as lamenting the fact that its documentation hasn't kept up with engineering.
So back to the original issue: I think great documentation is much more of a value add than adding new features, and this is an area where someone who may be good with ColdFusion but not Java (which is what all version of ColdFusion are written in) can help.
The best thing about a boolean is even if you are wrong, you are only off by a bit.
I hear you,
yes open source does not mean open minded. By their nature projects are meritocracies, only those that show effort and quality are accepted as contributers. And Google is you friend.
That means you can build documentation, and tutorials w/o permission of the actual projects owners. I have done it at http://plan-b-for-openoffice.org/index. I build a documentation project with 1,000+ videos and did not even ask for permission. And recognition has come in form of links from the official project website and posts in forums that reference my material. If you do some terrific documentation Google will help people to find it. And if you are consistent and also work with the community in their forums, mailing lists, bug tracking system, then most of the times they'll come around and recognize you. If not you still did follow your passion, helped your favorite project become more popular and had a good time finding others that feel passionate about the same project.
Many, many open source projects need a marketing strategy and execution (did I say execution). It starts with descriptions of the project, the target audience (library for programmers, end users, supported OS, functions/features, competition/comparable projects, positioning (faster, smaller, more beautiful, supported, ...). Also gather stories from users, how they use it why and what they'd like to improve. Also don't forget history.
Make this knowledge available in a thoughtful way, if possible on the projects home page (how often is the home page indecipherable
Then spread this knowledge on websites like http://wikipedia.org/ http://ohloh.net/ and others that catalog open source projects. this makes it easier for potential users to find the project and pinpoint if they want to use it.
Busy helping non technical users of OpenOffice.org - http://plan-b-for-openoffice.org/
Another great way to contribute is through complex testing, such as vulnerability testing, penetration testing, security testing, performance testing.
You do not need to be a great coder to run a test app, if you happen to have access to it. Run it and report the results or even better turn it into singular bug reports.
The same is true for performance testing. If you use a particular project, see what performance characteristics are important to you and distill a canned test with appropriate data (so it is reproducible). If you can run the test against different versions, to show a trend of improvement or not that is certainly helpful. If you can compare different (competing) projects that is helpful too. In the process you have a lot of interesting things to say and write about.
Busy helping non technical users of OpenOffice.org - http://plan-b-for-openoffice.org/
Generally, you can contribute in any way suited to your abilities! Do some graphic art, proofread, compose music, design icons, write documentation, edit the documentation so it's actually fun to read, write unit tests, compose a propaganda flyer, ... if you're a student, apply for Google Summer of Code-- you can write your own proposal, and nothing says it has to be about coding!