Category: opensource


You’re Open Source…Now What? (Communication – Part 3)

June 24th, 2011 — 9:01am

So, what started out to be a post or two on some of the important things to consider about communication in open source projects, has now turned into it’s own little mini-series. In part one I talked about some of the important things to consider when it’s you, the organizer, talking to the people that come in and want to get involved with your project. In the second part I covered some of the organizer-to-organizer communication techniques to keep the project running smoothly.

In this part I’m going to focus on something that’s a bit harder to control, but can still make a huge amount of difference in your project’s life. Contributors talking back and forth with the organizers is fun and all, but sometimes they just want to skip a step and go directly to another developer. Dev-to-dev communication is absolutely necessary to make a project thrive. If a developer comes in and the only chatter they see on a mailing list is the project’s admin taking to various people, chances are they won’t stick around too long. People want to see life, they want to see lively discussions and ideas being explained and played off one another.

There only one real issue – you can’t control this.

You can, however, make use of some tools that make it a lot easier. As I mentioned, mailing lists are great tools to have for your contributors to ask questions and get their own ideas across. You have to encourage this, though – it’s not just going to magically happen. Sometimes you have to get the ball rolling by asking a few questions yourself first, but once that ice is broken conversations will more easily pop up. Even just a response or two to a question you posed to the list can spark ideas from other developers not even interested in the original thread. Challenge yourself to, at the start of every week, try to come up with a topic that you think needs to be discussed on the project and start a thread on the list. It’s okay if the majority of the activity at the project’s start is from the organizer(s). Lots of people have their opinions, some are just more forthcoming than others with them. Having a good “feel” for the list helps bring these out.

A second tool that can be invaluable for any project, just starting out or already mature with its contributor base in hand, is something that several of the code repository sites (like github or Bitbucket) offer as a part of their service – the ability to look at the changes someone’s committed to their branch (or to trunk), see the differences and comment on them right in the same page. Previously, version control systems have sent out commit emails that might have included the diffs from one version to another. This is good and all, but developers would need to respond to these emails with their suggestions and, well, as I’ve already mentioned, email is really more about the point-to-point rather than for lengthly discussions.

There’s a huge benefit to having a record of all comments related to change in the code right there in front of you. Github will even let you make a comment about a specific line in the change and all parties involved in the discussion are notified. No more batting around emails and trying to keep track of how many “Re:” there are in the latest response.

The final recommendation I’ll make is probably the most tricky depending on the size of the project. If at all possible having developers on your project physically in the same room makes amazing things happen. Take, for example, the Hackathon that happened at the last php|tek conference. Several developers were all there with the intent of working out some of the bugs in the Joind.in project as well as several others (including writing tests for PHP itself). Remote communications can be efficient, but there’s nothing quite like sitting across the table from another developer poking around the same code you are and hashing things through. Obviously, the Hackathon was a rare event, but if you’re even able to just get two or three contributors together, do it. Conferences are a great place to organize things like this – there’s people from all over that already know the project and look forward to the community that comes with other developers on the same project. There’s even the possibility of drafting new recruits!

Developer -to-developer communications is one of the hardest to get right mostly because it’s not really something you can control. It’s more of a “throw it and hope it sticks” kind of thing that can really pay off in the future of your project.

2 comments » | Development, opensource, PHP

You’re Open Source…Now What? (Communication – Part 2)

June 23rd, 2011 — 9:03am

In case you missed it, this post is a continuation of another post looking a some of the things I’ve learned in the time I’ve spent as an open source project organizer for Joind.in. In this second post I’m going to keep looking at communication and the role it plays in the project. The focus will be a little bit different, though – this time it’s more about internal communication.

Keeping all of the contributors to your project informed and involved is a task to itself, but this should be only half of your focus. It’s easy to get caught up in the code merges, mailing list threads and even heated IRC conversations about the next fixes that need to be made. It can be fun, trust me – there’s times when it’s easier to just think about the code and where the popular opinion says it should go. Unfortunately, this almost always leads to bad decisions.

See, one of the core things you can’t forget about when you’re organizing an open source project is to keep the “staff” all on the same page too. When you start off small and it’s maybe you and a few casual committers, it’s easy. You can pull out the decisions without having to worry about anyone else. This all changes when you have one or more others come in and start to be a part of the project. It’s a tough transition for a lone gunman developer used to calling the shots to flip that switch in their head labeled “ask the team”. It’s crucial that everyone involved in running the project be on the same page about things. If they’re not, that’s when bad things can happen like major code forks or worse – a poisoning of the project’s community.

I know in the previous article I advocated keeping things out in the open when dealing with the project and its intentions, but there’s a “but” that comes with it. Contributors and casual observers don’t need to be in on some of the organizational decisions related to the project. There’s things related to the code of the project and then there’s things related to the project itself. It’s up to you and your fellow organizers to make the call on what discussions belong where. Usually the line is pretty clear, but somethings a “let’s ask the community what they think” is the right way to go.

So, how does a (possibly) completely remote team keep up with one another? Well, here’s a few ways, some being better than others:

  • Email – one of the more cumbersome techniques due to it’s nature as more of a point to point method. This can work if there’s only 2-3 of you, but when it starts growing past that, this just gets confusing
  • Mailing List – this is a step above the emailing method and at least will give you a way to review the threads in case questions pop back up. Still not great, but better
  • Online project management apps – these can be great if you need something with a bit more superpower to help manage the project. Even something as easy as Basecamp can help.

The real key is to finding something that works well for your project, though. Sometimes it’s enough to just keep a running list of decisions/future plans made about the project, but I’ll warn you that you’ll outgrow this pretty quickly. It just doesn’t scale very well for anything other than a 2-3 person project.

Thankfully, keeping your project’s “staff” informed isn’t as difficult as keeping up with the general contributor base. It’s easier to just tell them where they need to go rather than trying to get the message out to as many people as possible and hoping it sticks.

Do you and your project have a tool or method that you use to keep all of the admins on the same page? Share it in the comments!

Comment » | Development, opensource, PHP

You’re Open Source…Now What? (Communication – Part 1)

June 22nd, 2011 — 8:55am

I’ve had an idea rolling around in the back of my mind for a little while now and the Call for Papers for ZendCon brought it up and into focus in the last few weeks. I am a part of the Joind.in project, a community event feedback site that’s also an open source project. My co-conspirator Lorna Mitchell and I have worked hard over the past year or so really trying to make the project the best it can be. There’s been a lot of learning that’s gone on during that time, so I wanted to share some of that in a series of blog posts.

This first post, as the title mentions is about communication. I’m going to break it up into two parts because there’s really two different sides to this one word when it comes to a project with so many moving pieces.

Communication with the Group

The first and more obvious form of communication people of think of when working with an open source project is talking to the community at large. Once you take that step an decide to open the source for your application, you’re no longer alone in its development. Sure, you might be the only one committing code to the project, but that doesn’t mean there’s not interested parties out there keeping an eye on your work. This is the first thing to consider as communication from your project to the outside world – the code you write. Even the best, most elegant code without some kind of commenting or internal documentation will fall flat. If there’s nothing helping an outside developer to understand your code and the design of it, chances are they’ll abandon it before they even get started.

Following this same line of thought, there’s the next most important (maybe more important?) form of communication for you to share with potential developers – project documentation. I know it’s been hounded to death by this point, but please don’t wait until the very end of your coding to write documentation. Yes, it’s a pain, but with so many tools out there (like the excellent DocBlox) to help you generate documentation, you have no excuse. Auto-generated docs are great, but real human-made files that include examples and descriptions are even better. Don’t forget to put a human side on your project – it draws in more contributors than just code comments alone.

The “human touch” brings me to the next topic under communication – personal interaction. Comments and documentation on the project are one thing, but if you really want to get people involved and get them as excited about the project as you are, you need to reach out to them on a personal level. There’s lots of ways to make this happen including:

  • mailing lists (we have ours split into “developers”, “features” and “site news”)
  • an IRC channel (#joind.in on Freenode, stop on by and say “hi”)
  • a blog
  • a Facebook page
  • a Twitter account

It’s an easy thing for a developer of a project to just want to stick with the code and get tunnel vision when it comes to the overall project. I’m going to go so far, though, as to say that if you don’t choose at least one of the things from the list above, your project will not succeed past the point of you and maybe a few other developers hacking on the code. At the recent php|tek conference in Chicago, there was a hackathon one night where several (I think it was around 8 or 9) folks all sat down and worked on Joind.in bugs. This was excellent except for the fact that I, one of the project leads, wasn’t able to be at the conference. This is where the IRC channel became invaluable – Lorna was there helping but there was only so much of her to go around. Me being able to have an official place for those people to come and ask questions was a huge boost in productivity over something like email.

Two things to remember, though – having these things is great, but don’t spread yourself too thin. You don’t have to have all of the things from the above list to make a successful project. Pick what fits your needs and the needs of your group. Remember, not everyone that’s interested may be a developer. Also, and this goes hand in hand with #1, don’t forget to nurture the communities you build. I’ve seen first-hand how things can drop off if the driving forces behind the project aren’t there to help drive these interactions. The past few months my time was increasingly eaten up by the conference I was planning and I just wasn’t able to spend the time with Joind.in that I wanted to. As a result, the mailing lists ran a bit dry and even the IRC channel was sparse. I’m on a mission to turn this around, though and am doing what I can to keep our current developers and bring in those shiny new faces eager to hack away.

Disclaimer: Okay, so I lied a little bit – turns out there’s more to say on this topic than I thought, so the second part of the “communication” idea will be in a “Part 2″ post coming soon. Until then, here’s a few suggestions for the project organizers out there about communication with your developers:

Suggestions

  • Be transparent – don’t hide decisions from your community. No one likes surprises, so do them a favor and let them give their input
  • Be consistent – you and the other project leaders need to present a united front on decisions. No “ask him, he’ll say yes” sort of thing
  • Be polite – yes, there’s going to be “those people” that seem to live to cause trouble, but deal with them politely. You never know who’s listening
  • Be a dev leader – this is an easy one for the project leads that are still developing, but for the others this could mean moderating pull requests or being familiar enough with the code structure to answer some high-level questions

In the next post I’ll talk more about the flip side of this – communication within the project between organizers and some of the difficulties that are hiding in there.

2 comments » | Development, opensource, PHP

Back to top