The "Road to GSoC" is paved with learning and fun!
As Organizations are finishing up Google Summer of Code for 2018, I would like to spend a few posts highlighting this Summer's projects at the
OpenWorm Foundation and
Orthogonal Research and Education Laboratory. In this post, I am
reposting Arnab Banerjee's blog post on his experience with open-source development. He worked on a project called "
Physics-based XML Model building for mosaic embryogenesis of Caenorhabditis elegans" (
project repository,
proposal presentation).
I have recently completed a
Google Summer of Code (GSoC) 2018 student project as part of the
DevoWorm group and
OpenWorm Foundation.
Being a newcomer to the world of open source, it might seem a little
presumptuous of me to write an article about the stages of becoming an
experienced open source developer. But this article has resulted from
personal experiences in the Open Source community, and so should be
useful to open-source project newcomers and future Summer of Code
students alike.
I would like to begin by sharing a metaphor. Imagine a group of mountain climbers trying to get to the summit of a mountain.
There are some who are doing it for the first time - the
BEGINNERS.
They find it difficult to get used to this activity and it is all new
to them - from maintaining rations of water and oxygen cylinders to
getting used to the physical exhaustion. Then there is the psychological
factor - the will power and ability to keep going forward despite
setbacks. The psychological and physical factors combine to make this
period fraught with unexpected challenges.
Then there’s another group who have already done this a few times
before. They are definitely more confident in their abilities, but not
so good that they can lead an expedition to the top. They know how to
maintain the rations like water and oxygen up to the correct levels
because they have experienced it a few times before already. Willpower
is also a little stronger than the beginners. These are the
INTERMEDIATE climbers.
Finally, the group leading the expedition - the
EXPERIENCED -
have done mountain climbing dozens of times. They lead the entire
movement - from allocating resources to other climbers and deciding
course of action in case of disaster. The remaining group looks upto
them for directions when they are stuck. The rest of the group draws
inspiration from them too, because they are the leaders of the movement.
The EXPERIENCED have already been successful at the act of mountain
climbing and learned from their failures - but they still keep doing it
and training the others to reach higher and better positions.
I’m sure by now you might have guessed that these grades of expertise
parallel the world of open source development. As with
mountain-climbing, I believe there are 3 distinct classes of developers
in open source:
1. Beginner - A beginner struggles with basic concepts like
version control systems. Also diving deep into the code base of an
established open source organization seems difficult at first. As with
mountain-climbing, the learning curve is steep. But once the initial
effort is made, steady progress is seen.
2. Intermediate - Intermediates are ore comfortable with basic issues like using Git
or version control system more generally. Intermediates can become
familiar with the code base in a shorter amount of time, either due to
organizational experience or experience with interpreting code more
generally. In working at the intermediate level, time management becomes
an important skill to build. Along with contributions to code base in a
limited amount of time, other work like collaborating with teams and
community bonding become important skills to master.
3. Experienced - The experienced are leaders of their
organizations, and decide the overall strategy for these organizations.
Experienced open-source contributors allocate new comers to issues to
which beginners and intermediates will fit well. Other roles include
conflict resolution and making sure that the organization functions with
efficiency. Technical expertise (strong coding abilities) and a firm
grip on domain-specific knowledge makes them natural leaders.
I believe after my GSoC journey, I have almost reached the end of the
first 'BEGINNERS' phase. It was both an educational and rewarding
experience. The initial weeks were tough to get used to because coding
was one of many things I was simultaneously juggling - blog progress,
mentor calls, community bonding, documentation, and domain-specific
knowledge (learning about embryogenesis and neuroscience). Here is a
visual aid in cartoon form (slideshow).
Prior to my experience with GSoC, I couldn’t have pictured completing
such a project with a neuroscience domain organization, but the massive
support that I received from the larger
OpenWorm Foundation community,
Dr. Stephen Larson, and especially my mentor
Dr. Bradly Alicea. Bradly introduced me to the
DevoWorm Group,
and was instrumental in whatever I have been able to achieve this
summer. I learned from them that dozens of contributors sitting in 10
different time zones can collaborate to work on a project that has the
potential to impact an entire community of researchers and developers.
CONCLUSION - Aiming for a moonshot project
I hope to keep dedicating myself at least part-time to the cause of
OpenWorm. The OpenWorm mantra is “building the world’s first
worm-matrix, one line of code at a time”. The
project that I worked on
has given me a good foothold and introduction to the world of open
source - especially the OpenWorm Foundation and DevoWorm Group. Now,
there’s no turning back. I have decided that I will contribute to the OpenWorm Foundation by integrating my GSoC project with the
Geppetto modeling environment.
Technically, its a moonshot project and will not be easy to achieve.
But HEY! I just participated in GOOGLE SUMMER OF CODE. As they say at
Google: "aim for moonshots; its easier to make something 10X better than
10% better". That’s what I’ll aim for - a moonshot. Let’s see where
it takes us - me and the OpenWorm Foundation. At worst, I end up
contributing some useful code and learning something interesting. At
best - well, we integrate DevoWorm with Geppetto!
