5 CS skills I wish I learned in college


Lindsay Hall, Software Engineer (Google NYC)

I started working full-time as a software engineer Lindsay_Hall_1(SWE) at Google NYC in 2012, after graduating from Harvey Mudd College with a degree in Math and Computer Science. Prior to joining full-time, I did 3 SWE internships with Google, working at YouTube in the San Bruno office and with the Google Docs team in NYC.

By the time I did my first technical interview with Google, I was fortunate enough to have learned the skills and Lindsay_Hall_2topics usually covered in these interviews, which tend to focus on coding, algorithms, and data structures. In general, if you can pass a Google technical interview, you can learn the rest of the skills on the job, but there are some key areas where I wish I’d been better prepared in college.

A college degree is generally supposed to prepare you for a job in that field (hopefully we can all agree on that). Obviously, software engineering isn’t the only field you can enter with a degree in computer science, but there are over 1 million software engineers in the United States, and the field is expected to grow by almost 20% by 2024. Are college-level CS programs really teaching the skills required for students to become professional software developers? Well, yes and no. Here are some of the topics I think were covered well in my program, and some of the areas I think were lacking.

Things that my college program did well

Many of the skills I learned during my time at Harvey Mudd College continue to be invaluable to my job at Google. These include:

  • A rigorous background in algorithms and data structures
  • Coding knowledge, including experience coding in multiple languages (Python, Java, C++, and others) and an understanding of the difference between various types of programming languages
  • Experience working closely with other engineers to solve problems together
  • Practice explaining technical concepts to an audience, either in written or presentation form
  • An understanding of how computer science can be used to solve problems outside of purely technical fields

5 things I wish my college program had taught me

Despite all of the amazing, important things I learned in college, I spend most of my day doing things that I never learned how to do before joining Google. Here are 5 topics that are critical to my day-to-day job at Google that I think should be required learning for all college CS students.

1- Working in an existing codebase

Unless you’re founding your own start-up, it’s highly unlikely you’re going to be writing any significant code from scratch as a SWE. The very first skill I had to learn at Google was how to read and understand the existing code for my project, and how to integrate my changes into that codebase while adhering to the design patterns already in place.

College CS courses tend to focus on writing code from scratch, or implementing methods in an existing class. I’ve never heard of a class which required students to understand and make changes to an large, pre-existing codebase (although such a class might exist!). This is a crucial skill for future software developers and one that should be stressed in college curriculums.

2- Testing code

Writing automated tests for your code is a huge part of working in a large codebase. Tests help ensure the correctness of your code, provide information about the expected behavior of methods/classes, and protect your codebase against future regressions. Test-driven development is also a popular strategy for software development at many companies.

A few of my college courses required students to write unit tests for their code, although there was never any emphasis on testing strategies or best practices for writing unit tests. While unit testing is a big part of  the test suite at many companies, other types of testing are critical as well, including integration testing, screenshot testing, and automated testing of production code using a prober or a bot. Understanding testing practices and the importance of different testing approaches is critical to working as a SWE, especially at a large company.

3- Writing design documents

As I mentioned earlier, I was fortunate to attend a college that placed a strong emphasis on technical communication, both written and verbal. I would say the single most important thing I do in my day is communicate with my coworkers, whether it be about code that I’m writing, code that they’re writing, or a design that we’re working on together.

A design doc is a key component to working on a project at Google. Before you start writing code, you need to outline your proposed changes in a format that can be easily shared with your team members and reviewed by at least one coworker. Doing these reviews before you start coding saves a lot of time and energy, since you can iterate quickly on various design ideas without having to update your code each time. Learning how/when/why to write a design doc or proposal is a skill I wish I had learned before starting at Google.

4- Conducting code reviews

Many companies adhere to a code-review process where every line of code that’s submitted to the codebase is reviewed by at least 1 other engineer. This allows for a 2nd pair of eyes to catch bugs and suggest improvements, and also helps to spread knowledge among the team (so that at least 2 people know how all of the recently-submitted code works). Learning to review someone else’s code for correctness, style, and good design is an important skill. Also, it’s important to learn how to have your code reviewed, and how to take feedback and suggestions (and when to push back on those suggestions).

5- Working on large-group projects

At Google, there are often many working on a single project at any given time. In those situations, it is critical to break up the work in such a way that peoples’ changes don’t conflict with each other, and everyone can be productive without being blocked on someone else’s changes. Learning how to parallelize the tasks in a project and coordinate across a large number of engineers is a critical skill. While some college courses encourage or require group work, most don’t require students to work in groups larger than 3-4. Learning how to manage a long-term, multi-person project as part of a CS class would be a large benefit.

About the author:
Lindsay Hall is a software engineer at Google. She joined Google full-time in 2012, where she started working on the Google Docs web team. Since then, she has worked on Google Slides (both web and Android), the Docs performance team, and currently works on the Google Sites front-end web team. Prior to joining Google, Lindsay attended Harvey Mudd College where she gained a BS in Math and Computer Science. While at Mudd, she completed 3 software engineering internships with Google, working on YouTube and Google Docs. In her free time, Lindsay enjoys taking aerial silks classes and swimming on the Bearcat Masters swim team.