Disclaimer: It’s sad, but there are many examples of bad leadership in the open source sphere. I normally don’t want to do name calling, but I think that  learning by example is a good approach in this case. If you feel insulted by one of the examples, feel free to drop me a line and I’ll rewrite or delete the example.

Are you a ruler or a leader?

You have started a project and it’s your baby. You have a few people helping in the project and they trust your decisions. As the project progresses, conflicting interests appear. Maybe it’s because of the main direction of the project or just features someone wanted to implement that don’t fit in your agenda. This happens a lot. When this has happened before and their ideas have not been appreciated, then often the people step back and don’t do the stuff they’d like to accomplish.

This may be the result of a general pattern that has established in your project. People don’t step up to their opinions because they’re used that they can’t get through with it anyway. At least they think that this happen. This is a dangerous state for a project. People will be drawn away from the project in the long run or maybe a revolt will form and the project is forked by the disappointed members.
So what can you do to to prevent your project from going down that road? It’s as simple as it’s important: treat your project members as equals! Of course a project needs someone who makes sure that the project has a clear vision, but try to keep a balance between the vision and the reality. Maybe the vision just needs to be updated to reflect the vision of the whole team. The difference between a ruler and a leader is that the leader is open to eliminate or postpone some of his wishes in favor of wishes of the team or team members. This creates a more open environment which enables the project to grow and prosper.
Long story short: Try to keep an open mind for input from your team and your users. Periodically reflect if you are really listening to them to make sure that a bad atmosphere not slowly sneaks into your project.

Your behavior influences the reputation of your projects

Even if you are nice and understanding to your team members (or you don’t have any yet), be aware that your behavior in forums, mailing lists etc. is visible to others. It’s sad, but there are many people out there who don’t think about the effects that their behavior has on their online reputation. Some people even don’t care and misbehave in publicly visible places.

There are many prominent people with – let’s put it that way – questionable social skills. Starting with more or less rude behavior of well known “open source gurus” like Linux Torvalds, whose rants are widely known. But there are also people like the author of one of the best cd/dvd burning programs for linux/solaris/… who is known for his rude behavior. Linus has earned enough reputation that his behavior has no bad effect on his projects like git or the linux kernel and his projects have many people who join them or want to join them. On the other hand, our good friend with the cd/dvd burning application is more known for his rudeness and you won’t find many people that really want to work with him.
In short: Be nice or your project and your “karma” may/will suffer!

Conclusion

There are many things you can do wrong when you’re communicating with your project members or in public channels. Keep in mind it’s a good approach to treat others like you want to be treated yourself. This often helps to keep your communication straight and honest. I like the concept of karma that Tobias Schlitt mentioned in his blog post. And you don’t want to mess with karma, so be nice! ;-)

References

• http://greg.chiaraquartet.net/archives/171-10-golden-rules-for-running-an-open-source-project.html
• http://schlitt.info/opensource/blog/0541_10_golden_rules_for_starting_with_open_source.html

Delegate!

When you have started the project alone and created the first versions on your own, then you might think of it as your baby. It’s not easy to give up responsibility for certain areas. But the amount of administrative work will grow with the project. Try to find areas that you can delegate like Website maintenance, forum moderation or things like that. After a while when you know the other developers better, then you’ll find it easier to assign other tasks to them too. Just practice a little bit. ;-) To summarize this:  Try to delegate even important tasks to capable trustworthy members to free up time for important things.

“Activate” non-programmers

After a while your project might form a small community of users. They often communicate via forums, mailinglists, IRC or something like that. Then you’ll have the chance to convince some of the users to help you, even if they are not programmers. Regular users that feel connected to the project, sometimes like to help as well. Try to leverage that enthusiasm and ask if they’d like to help. They may help you for example by:

• by doing official support in the forums/irc
• help with improving the usability
• helping with the Website “maintenance”
• being the “community manager”
• design for the homepage, the UI or a logo/”corporate design”
• PR work/booth duties at conferences like LinuxTag, UbuntuCon, …
• collect donations to fund the projects
• …

In short: Don’t focus your search for help only on programmers. Every user may become a very useful member of your team.

External developer resources

Sometimes companies use your software and they need a certain feature or have other interest in your project. When you are lucky, they’ll assign one or more developers of their staff to your project (if you allow this) and they’ll work on it in their work time. Or the company pays members of your team to implement something they need. This is not uncommon, especially in projects like frameworks, EPR systems, shopping carts etc. Just be sure that the stuff they are demanding fits in your global plan. Don’t let pure economical reasons drive your project or it will soon be off the track! Other ways of getting help are sponsored events like the google Summer of Code. You can apply with your project for certain programming tasks and when your project is chosen, then google will pay a student for a summer to perform that task. This has several advantages for your project. You will get a lot of visibility in the public which may result in more people using your software or joining your project. You will have to  select two mentors that will have the chance to fly to the US and be part of the mentors camp that google organizes before the whole thing starts. But be aware of the dates. When you are late, then you’ll have to wait for the next year. And don’t be disappointed when your project has not been selected. Just apply again next year. I’ll try to find a project that has participated before and interview them for a more comprehensive blog post. Long story short: Paid development is a chance for every project to get a boost. Try to apply for the google SoC or try to find partners in the industry. Just be aware of the responsibility that the project is first, not the money!

Conclusion

So, there are many ways to find people that help you in your journey and don’t be afraid to let certain tasks go. You can’t do everything on your own and other people are eager to be part of the project. It’s important to find people that help you, if you want your project to live a long and healthy life. There are always people leaving and joining, so the bigger your team is the more people you have constantly working on it. Maybe with the google SoC or paid development you can attract even more team members with whom you can share the work and maybe even the important tasks. Try it!

So you attracted a new member…

Especially when you’re team is small, then it’s a big deal when new people join it. You are eager to integrate them, but there are many things you can do wrong and drive them away from your project. It’s not an easy task if you are not used to it to get someone involved. And you always have to take care that you don’t ask too much of the new member or bore him to death. In short: when you have a new member, try to keep him interested but protect him from “information overload”.

“Here read this comprehensive guide…”

There are projects like debian for example, that have a pretty rigid recruiting process. You have to prove worthy for a long period before you gain the rights to really participate. There are other projects out there that also follow this principle, which basically is based on mistrust on new developers. That is understandable for projects that are as big and popular as the debian project for example, but this approach has several disadvantages that you should keep in mind. Your project has the possibility to keep only the “best” developers and discard the ones you don’t like in the process before they can do harm. This sounds good in the first place, but you also discourage many good people from trying to get involved because they don’t like to be treated in this way. And even the people that survived the selection process may turn out as “malicious” in the long run. Long story short: think about the negative implications before setting up a rigid process.

“He joined and was never seen since… :-(“

One thing that you’ll notice very soon is, that people are very excited about your project, do everything to join it and maybe even start some tasks and suddenly they keep a low profile. You’re trying to contact them and receive no answer on your mails, IM messages etc. Many people think that they have done something wrong and repelled the new member. But the truth is that this happens a lot. Sometimes the people will write back a few months later and apologize but most of the times they play dead after they realize that they should have contacted you because they are embarrassed. When something like this happens, think if you might have done something wrong, If you find nothing obvious, you can be pretty sure that it’s not your fault. Long story short: people sometimes disappear because of personal reasons –  this is pretty normal, get over it.

“OMG he killed our source code repository…”

When you’re project is very small and new people join, then it’s not unlikely that you want to integrate them as soon as possible into the project. So you’re giving them administrator rights at sourceforge and the password to the webserver to keep them busy and give them the freedom to help in any way they like. This sounds silly if it’s written down in compressed form, but this happens and sometimes this has negative consequences. The new member might damage parts of the infrastructure either intentionally or by accident. This is not unlikely, because especially non-linux/-unix people have often problems with shell access, ftp, file permissions etc. In short: Take care that only people you trust and who know what they are doing get unlimited access to the core infrastructure of your project!

“He is so lazy and always asks dumb questions…”

Some people expect that new members have from the start a complete understanding of the sourcecode and the underlying infrastructure, of course they also should know all the tools they need. If they don’t then it’s their duty to learn it before they ask dumb questions… Another variant of this behavioral pattern could be described as “fire and forget”. You introduce the new member and then he is on his own, without help and guidance. Sadly quite a few projects act like that and many new members get disappointed and leave the project soon. It doesn’t have to be this way and even when this is a spare time project, the “old wise members” should take some time and help the new members. Just because they don’t know everything yet doesn’t mean that they won’t be helpful members after they got properly introduced in the projects technologies and procedures. To summarize it: there are no dumb questions, only dumb answers! Take your time with the newbies it’s worth it!

“I do my very best to help him…”

The direct opposite of the mistake above is that the project is too protective and too “kind”. The new member is bombarded with good advices, links and help offerings. This may as well drive people away. It looks desperate and may drive the new members crazy. Offering too much help introduces a feeling of pressure, even if it’s not meant this way. In short: Don’t exaggerate with help offerings, try to balance between negligence and over caring.

Setting up a process helps

To avoid the problems I have mentioned above, you should think about introducing processes. This might sound boring and you don’t like it, because it reminds you on your work, but clear guidelines help new people to fit in the group and learn the processes that exist anyway, no matter if they are written down or not. Thinking about the processes helps to improve them. Consider for example check-in or code style rules. Every project needs some kind of common understanding in theses areas and new people need to learn these. Without written down rules, they have to do trial & error which can be pretty frustrating. Even harder are social rules like who is responsible for what and who decides when there are conflicts. You should consider if it’s possible to assign a mentor to the new member, so the new one has one dedicated person to ask questions. But the mentor needs to be motivated and willing to help. Otherwise it will do more harm then help. Long story short: By formalizing the internal rules and roles you make it a lot easier for new people to blend in.

Knowing their motivation

Everybody who joins a project expects something in return. Some people like to participate in publicly highly visible projects to get reputation in a field, others just like to code and practice their profession or hobby. Of course there are much more different aspects why someone joins a project, but as a project lead you should try to find out what the motivation is and help the members to get the most joy out of their involvement. You can do this by giving the right tasks to the right people, giving credit to the team or even assigning roles to people, so they can do what they like most.This way you can maintain a healthy project with satisfied members. As a summary: Knowing the motivation of your fellow team members and acting to fit their needs will greatly benefit our project.

Comprehension

There are many ways to drive people away from your project, but there are also many ways to attract them if you do it right. Take your time to introduce new people, maybe select mentors that help the newbies in the first few months. Be clear what you expect from people and where you help them to shape their expectations and prevent them from being disappointed.

It’s more fun if you don’t do it alone

As mentioned in the second blog post, open source software exists because passionate people join in team and produce software. Working together is a great aspect of being in an open source team. If you have never worked in a small/medium sized team with nice people, then you’re missing a great opportunity. When you’re working in and with the team and you’re spending hours in mailing lists and chats, then you’ll have the chance to form friendships with your team mates. Team meetings are also a nice way of getting to know each other. I’ll write a separate article about this later. So please keep in mind: Working alone is boring. Collaborating is fun.

Training social skills

Rumors exist that IT affine people are socially “not that well educated”. Participating in a project is your chance to change that, if you’re belonging to this group. ;-) When you’re in a team, sometimes conflicts happen. Especially when you’re the project lead then you’ll have the chance to exercise your conflict solving skills. Small teams are normally pretty easy to handle, but starting at medium sized teams you’ll see several kinds of internal conflicts or struggles, which are perfectly normal when a group of people comes together. There are always some people who don’t like each other or can’t integrate in the group. If you notice that, then you can try to help in solving the conflict. This is great for training this kind of problem solving. Things like this will happen in your work life anyway, so it’s better to practice when your career is not in danger, when you mess things up. ;-) So as we all know, social skills were getting much more important in the last decade. In short: Being in team can improve your social skills – try it!

Communication training is expensive – helping in a project is free

All well running projects require a lot communication, either internal or external. Especially for non native speakers, it’s a chance to improve their English. Most projects use English as their default language to make it easy for developers from any country to join the team. If your project has no one who handles the external communication, it’s your chance to step up and do it yourself. It’s a good training and depending on your user base you even might get some constructive feedback on your announcements and other form of communication. Long story short: Communication is of great importance in every aspect of our daily life – take your chances to practice…

Conclusion

Working in a team is the fun part. Get something from your open source involvement back and improve your social skills. You can even train your other communication skills and your English, if you’re not a native speaker. Open source is not only for students and unemployed people. Improve yourself by helping others…