Like A Girl

Pushing the conversation on gender equality.

Code Like A Girl

Monsters Under The Bed

Things You Didn’t Know About Software Engineering and How to Learn Them

Software Engineering : Expectations vs Reality

As a CS undergrad, when I started programming, the only extent of code I wrote was to solve basic problems, perhaps automate a few tasks at most. That was all. I was the only person working on my code and testing was unheard of. Code quality and maintainability were alien concepts.

But as I progressed to collaborate with other people and actually write code to solve larger problems, to actually develop software to suit certain design specifications, I realized that there was a huge gap between working on code fit for my eyes only, and what software engineering actually is.

As most of us transition from being students to being professionals in the software industry, we are often left high and dry, with very little or almost no knowledge of software engineering practices such as version controlling, testing, code analysis etc. Suddenly we find ourselves grappling with the scale of the code, floundering in CI pipelines and being baffled by Git.

How do we actually bridge this vast gap in our skill set? How do we actually know what it is like to work on a large scale codebase? How do we know what software engineering practices must we conform to? One of the simplest answers to this lies in plain sight — Open Source Software!

This is how most of us find ourselves at our first job or internship!

Software Engineering Practices & OSS

Most open source organizations maintain large projects, with overwhelmingly large codebases. As scary as this sounds, this is a perfect playground for anyone to gather a first hand experience of working on a project of this scale, to collaborate with people from across the world and orient themselves with actual software development.

Maintaining a project which is worked upon by people across the world, by its very nature requires some form of version controlling. By starting out into open source contributions, you’ll soon find yourselves poring over Git tutorials and project documentations in no time.

Open source organizations usually have a guide of standard practices in place, which help you tweak your code according to the style guidelines. CI pipelines subject your code to stringent tests before it can finally be included in the main project. Consequently you’ll be iterating over your code repeatedly, fixing each tiny bug, all aiming towards those sweet green builds and getting your code merged.

At the very heart of open source is the community, people who come together and work on a project out of their own volition. At each step of the way, you’re guided by people who’ve gone through the grind themselves. You’re never on your own in the world of open source!

Embracing open source!

Testing Times

No matter how grand your designs may seem in your head, no matter how artistic you think your code is, there is always a rough edge which makes your code unfit to ship. The larger your code base, the harder it is to find that one tiny mistake which causes your builds to fail. Which is where testing comes in. Testing protocols polish your rough edges on your code and makes it fit for being shipped to production.

Our Rails Girls Summer of Code project, coala, relies heavily on testing. A huge part of our task through the summer was to write tests for the linter bears we wrote. Writing good unit tests is a challenge in itself, as it requires you to anticipate all the possible places where your code might fail. Each coala bear requires an extensive test suite, covering all the possible points of failure of your bear.

The continuous integration pipelines at coala are very rigorous tests themselves. Soon we found our tests being tested. Test-ception 😛

CI mechanisms start poking and prodding your code as soon as you check it in and in our case, more often than not, yielded a huge set of build fails. There we found ourselves, iterating over our pull requests over and over again, bashing all those bugs and working steadily and incrementally towards the perfect code. Working with coala gave us a first-hand experience of what test driven development actually is.

Bashing those bugs be like 😛

Design Before You Develop!

Often the most critical aspects of software development that is grossly undervalued and often ignored, is design. Think, think and think before you actually code. Which is the best possible way to achieve your requirements? When you have a plan in place, ask yourself if you can do better. Is there a simpler way to do this? How can I optimize further? Ruling out all the unfeasible possibilities in the design phase is much simpler than changing your implementation at a later stage. Two words — design matters.

Let your imagination run wild before you actually code!

Writing each linter bear for coala required immense amounts of planning and design on our ends. Both Prachi and I delved right into the documentations of each of the linters we implemented and continuously brainstormed before arriving at our implementations. And not surprisingly, there was always something to improve upon and we found ourselves modifying our implementations based upon community feedback. The community has always got your back 😉

Just Get Started!

The bridge over the gap in your software engineering skills is just a step away. Take your first step into the wide world of open source. Find an organization, delve into its contribution guidelines. Just get started. You’ll end up learning much much more than you ever thought of.

Begin, and the rest shall be taken care of