If I reflect on how things have changed over the last 15 years, and I look at where we are now as developers, then I believe we are in a golden age. Actually it feels like a succession of golden ages. When I first started doing development, it was a quite solitary activity. The internet had only just hit the mainstream. You expanded your knowledge by reading books. The search engine of choice was Alta Vista. Open Source software was something that lived on SourceForge, was difficult to get a hold-off, and even more difficult to build and run. You were really out of luck if you were running Windows. Trying to install Linux was not for the feint of heart. Scrap that, you had to almost be downright masochistic to give it a go. Open Source was equated to
free as in beer by most and that was awesome in its own right. If you could get it to work.
Fast forward 15 years and Open Source has changed the way we plan, build, collaborate and consume software. With it’s widespread adoption Open Source has reached a new level, that we developers, product owners and companies have benefitted so much from. While it’s unfair to point to one singular thing that has made this happen, in my mind there is little doubt that one particular innovation has had the greatest impact and has led to this current golden age: Github.
Not because it is easier to find packages/tools/software and use them. No, because it has changed the way we talk about, interact and collaborate on software projects. As a result, I believe that you and your organisation should embrace the same model.
All too often we focus on the cost savings of using Open Source. Put aside this obvious and quite frankly hollow benefit of using Open Source in your products and look at what the Open Source model combined with GitHub can bring to your development practices, your team(s) and your product(s).
While I have been using Github for a number of years, I didn’t grasp its true power. I would have told you the flow was nicer than TFS and Bitbucket. At Red Badger we love Github, not just because it is a great Git interface. It allows us to collaborate easily and effectively. In the last 5 months, I have worked with it every day: committing code, opening Pull Requests, discussing/reviewing mine and those of my colleagues and ultimately improving the code of our project and my capabilities as a developer.
The other thing it has brought us is transparency. I used to read through the documentation and then try and get things working. When I got stuck, well I would search a little bit, if unsuccessful I would give up and move on. Now though? I look at the repo, the issues, look at the code, usually starting with tests (the hidden gem of documentation and the first client for your code). The answer to any question usually lies at the intersection of the code and tests. No need demos/examples… Well actually demos are still a good thing
:) Open Source and Github has made this so accessible.
While I wanted to focus on Open Source and the model in this post, I realise I have spoken more about Github. To be truly effective in adopting such a model, you can’t really do it without using Github. Just switching to Git will not have the same impact. When we engage with clients, we usually recommend using Github, and the response usually is:
Oh yes we already use Git.
If this is how you view GitHub you are missing a trick (or a dozen tricks).
Consider the individual in this model. Just think of how many people use and contribute to your favourite Open Source project. The collective power of this community that is using, reviewing and providing feedback makes the project successful and resilient.
Now think of your code and project, imagine having folks providing you with that feedback, suggestions and feature ideas? Would you not grow as a developer? Would your code not be better? Would your project not benefit?
Many of the things, that are true for the individual are true for teams as well. The added benefit is the greater level of collaboration and communication within the team and potentially other teams in your organisation as well since they now have visibility of your work too. Again code quality goes up.
At eBay, they found that people on different teams became more involved in other projects, more willing to lend a helping hand.
The other statement in the eBay post around modules developed in a vacuum and left to die when there was a re-org is also true. The team or individual was moved to another part of the organisation with no way to hand it over. I can attest to this on more than one occasion during my time at Microsoft, which made us reluctant to make use of internally developed modules. That usually led us to re-inventing the wheel, instead of contributing and making it better. I don’t mean to imply that there was no platform for sharing, it was simply inadequate.
An Open Source model coupled with a dependency management solution like NPM should lead to less re-inventing of the wheel. Instead, folks across the organisation can contribute to the solution. When they contribute and collaborate on the solution, the knowledge is no longer siloed, this leads to a shared understanding of the code. For the organisation, there’s now less risk, as the knowledge no longer resides with just one or a few individuals. As with knowledge, skills are also sharpened, by being able to see how others tackle problems and find solutions, by discussing these outcomes. These are all obvious benefits.
Building on the individual and the teams and their growth, products are almost naturally better designed, more resilient and more secure.
If your products are successful, built on an open source model and your developers can share their experiences, then your profile is raised. Better yet share your code, your modules, your libraries with the community and get the benefit of yet more people collaborating and contributing to these. With your profile now raised and individuals having visibility of your contributions, it is much easier to hire new developers: like-minded individuals that want to grow, contribute and collaborate.
The benefits to you, your team, your product and your company are in itself self-perpetuating when you adopt the Open Source model.