Brian Anderson shares a few thoughts on how to appear as a minimally-nice Open Source Software maintainer. Maintaining Open Source Software projects is a demanding job. And the more popular the project is, the more demanding it is. Brian shares the following practices that minimize the effort while you still maintaining a positive atmosphere for the project’s contributors:
In summary, do these things if you want to appear to be nice, and also if you want to actually be an effective open source software maintainer:
By consistently exhibiting a few simple behaviors, one can at least look like a kind and decent person. Maybe someday we all actually will be.
I came across this rather strongly opinionated blog post – GitFlow considered harmful, and I have to say that I mostly agree with it.
In our company, we use a similar approach to the Anti-gitflow, but with even more simplicity. This is one particular thing I like so much about git is that each person, team, or company can pick the workflow that suits them best.
Just to give you a little bit of context, we have a rather small development team (under 10 people), but we do a large number of projects. All our projects are web-based, varying from small and simple websites (static HTML), through more complex WordPress sites (multilingual, e-commerce, etc), to business applications like CRMs. Each project is done by several developers at a time and can later on be passed on to other developers, often much later (another iteration after several month). Each developer is working on a number of projects at a time. And we do very fast-paced development, often deploying multiple versions per day. Given the nature of the projects and the development pace, we don’t ever really rollback. Rollback is just another step (version) forward. And we don’t have long and complex roadmaps in terms of which features will be released in which version. It’s more of a constant review of what’s pending, what needs which resources, and what we can do right now. (It’s far from ideal project management, but it somehow works for us. If you think you can do better, send me your CV or LinkedIn profile, and we’ll talk.)
In our case, we do the following:
- We have one eternal branch, and we call it master.
- The master branch is always stable and deployable. Even though we don’t really deploy it directly.
- Nobody is allowed to commit directly to the master branch. Initially it was just an agreed convention, but because people make mistakes, we now have this rule enforced with the technology. Both BitBucket and GitHub support protected branches. BitBucket, in my opinion, does it much better.
- All new features, fixes, and improvements are developed in separate “feature” branches. Most of these are branched off the master. For large chunks of work, we can create a feature branch, and then introduce incremental changes to it via sub-feature branches, branched off the feature one. This allows for easier code reviews – looking at a smaller set of changes, rather than a giant branch when it’s ready to be merged.
- We do code review on everything. The strongly suggested rule is that at least two other developers review the code before it is merged. But sometimes, this is ignored, because either the changes are small and insignificant (CSS tweaks or content typos), or we are really in a hurry (we’ll review the changes later). But whatever the case is, nobody is allowed to merge their own pull requests. That is set in stone. This guarantees that at least one other person looked at the changes before they were merged in.
- We tag new versions only on the master branch.
- We use semantic versioning for our tags.
- We don’t deploy branches. We deploy tags. This helps with preventing untested/unexpected changes sneaking in between the review of the branch and the deployment.
The above process suits us pretty well.
Jason Fried has an excellent write-up on the pros and cons of using group chat for the team communications, and some of the ways to make it better. We use HipChat in the company and while it’s vital to our operations and I can’t even begin to think how we could do what we do without it, it does have some negative side effects – exactly as James describes them.
The most valuable advice out of that long article is this one (I’ve heard it before a few times, but it’s worth repeating):
Think about it like sleep. If someone was interrupted every 15 minutes while they were trying to sleep, you wouldn’t think they’d be getting a good night’s sleep. So how can getting interrupted all day long lead to a good day’s work?
Sara Rosso shares some thoughts on what to document and share, after publishing over a 1,000,000 words while working at Automattic. Here’s the gist of it:
- If you’re the go-to person for something in your company, consider how much of it is just gatekeeper information you could document properly to help someone else learn/grow from or work on independently.
- Separate out processes and historical background from your strategic expertise. Processes and backstory are not really ‘what you know.’ It’s much better to be a person someone asks ‘why’ or ‘when’ to do something vs. the logistics of a ‘how.’ How can and should be documented for others to build off of regardless of your involvement. This should free you up to be more involved in the why, the new, and the next of your work.
- If you’re repeating yourself in private chats or (gasp!) email on a specific topic, document it. That’s also what drove me to create this blog – being able to answer someone’s question with an answer you’ve already carefully crafted for someone else is a great feeling (and a great use of your time)!
- Will someone want to know why you decided or executed something a specific way later? Share as much background as possible so colleagues are brought up to speed immediately. Share the setup & thought process you went through, where to find more information, and even the facts, ideas, or information you considered but deemed outside of scope for the particular project. My goal is to hopefully never have someone ask “where did this come from?” or “what’s your source?” or “did you consider this?” (when I had) and instead focus on enriching the discussion or challenging my ideas vs. asking me for information I should have provided in the original post.
- Gather the best, most complete, or authoritative things you’ve authored and submit them as potential onboarding materials for new team members. Challenge them to ask questions and to find something you need to document.
- If important progress is made, be sure to update your documentation, or retire in favor of something newer or more complete. We do this by linking from old posts to new ones, and all it takes is a quick comment and a link on an old post.
Daniel Vetter, one of the Linux kernel maintainers, shares some thoughts on why maintainers don’t scale, what it takes to do the job, what has changed recently and what needs to change in the future.
This reminded me of this infographic, which depicts a year (even though back in 2012 – probably much busier these days) for another kernel maintainer – Greg Kroah-Hartman. Note that the number of emails does not include the messages on the Linux kernel mailing list (LKML), which is in its own category of busy:
The Linux kernel mailing list (LKML) is the main electronic mailing list for Linux kernel development, where the majority of the announcements, discussions, debates, and flame wars over the kernel take place. Many other mailing lists exist to discuss the different subsystems and ports of the Linux kernel, but LKML is the principal communication channel among Linux kernel developers. It is a very high-volume list, usually receiving about 1,000 messages each day, most of which are kernel code patches.
HipChat keeps extending the amazing list of integrations with other tools and services. This blog post – 35 new ways to do your work right inside of HipChat – lists some of the recently added. Included, among others, is even a multiplayer snake game.
Chat is becoming more and more important for team communication and collaboration (what is ChatOps?). Old school applications like Skype are being replaced with modern, web-based chat platforms, that provide group/room and one-on-one chats, file uploads, screen sharing, voice and video communications, API integration and more. There are plenty of solutions to choose from too.
Traditionally, self-hosted solutions were difficult to setup and maintain, and were lacking in integration options. So many teams choose to go for the third-party hosted approach. This is not very exciting for companies that deal with sensitive data though.
As mentioned before, at work, we are using HipChat. It’s nice, it’s free, and it integrates nicely. Lately, there has been a lot of hype about Slack, which I tried, but didn’t particularly like.
You can try the live demo, or deploy it to your infrastructure via a gadzillion different methods, or read the beautiful documentation. And there’s a rumor of HipChat and Slack import tool, so you won’t have to start from scratch…
Let me know what you think.
HipChat blog runs a rather lengthy post on what ChatOps are – “What is ChatOps? A guide to its evolution, adoption & significance“, which provides some insight into how the new generation of teams communicate.
At Qobo, we are at Stage 3 – Gimini, with a whole lot of dedicated rooms (one for each project, and a few more), some workflows (most notably “Hey Leonid, can you merge and deploy this pull request please“, or a shorter “@leonid, please m&d”), and some automation (we get monitoring notifications from Nagios and Zabbix, repository activities from GitHub and BitBucket, as well as do project deployments using slash commands).
We haven’t eliminated email completely, but combined with Redmine project management tool, we’ve significantly decreased the role of unstructured emails in our work.
Bitbucket is often viewed as second best compared to GitHub. And while I love GitHub dearly, I have to say that it’s not true. It’s as good as GitHub. Sure, it doesn’t offer all GitHub features yet (Releases, for example), but it does offer a few features of its own, which are not found in GitHub (Projects and Approvals come to mind).
With the recent advances in Atlassian Connect – an API integration layer – there’s been quite a few apps and services that extend Bitbucket beyond what GitHub users are accustomed to. Have a look at this Pull request guidelines for Bitbucket Cloud.
It looks simple. But it’s super handy and provides functionality, which is not as trivial as you might think.
GitHub blog brings us a piece of exciting news – now you can add more attachment types to comments. The list is no longer limited by images alone. Now you can attach Microsoft Word, Excel, and PowerPoint files, as well as plain text and PDF documents. This feature alone will make GitHub Issues into a much more viable bug tracking option for many projects and companies.