How to Survive Your First Software Engineer Internship
Tags: career, react, startup, codenewbie
Published: 2023-11-29 04:20:52

I'm halfway through my first software engineering internship at Swoovy. Despite having prior internship and full-time professional experience, the software engineer ways of working are completely new to me. 

## 01. Manage Expectation
In my previous role, I was often regarded as the most tech-savvy person in the room. Whenever there was a new tool or the Salesforce CRM software released a new version, I was that go-to person to figure things out and present my findings, and I enjoyed this process as playing with new toys. However, that's no longer the case when I started from scratch in a new field. I feel constantly challenged, and when I am assigned a new task, I don't have 100% confidence to nail it flawlessly, and surprisingly, it's perfectly okay. In fact, if every single task falls into your comfort zone, you should probably consider seeking new challenges elsewhere.

## 02. Navigate the Learning Curve
Another thing I noticed is that building personal projects is very different from working on a production-level codebase. When building personal projects, the majority of your time is spent on building new components and writing code. In contrast, I spent most of my first month acquainting myself with the codebase and reading existing code. In an environment with hundreds of components and thousands of lines of code in each file, pinpointing a specific component takes some effort. Also, I've never written a test case on my personal projects, but for enterprise software to be production-ready, unit testing is a must, so I've been learning Jest and Enzyme to ensure the code I wrote is reliable.

## 03. Raise Questions Early
During the interview, I asked our CTO Gerardo what kind of candidates would succeed in the role, and he painted someone who could set the expectations upfront, and bring questions to the table early. This might sound intuitive, but it really hit me on my first day ———— asking questions as a software engineer intern was not that easy. Just to give you a taste of the various challenges I faced:
- I spent 3 hours configuring my codebase setup and still couldn't get the project running on my local machine
- When assigned my first ticket, I didn't fully grasp the requirement
- In an attempt to resolve a merge conflict, I opted for "keep both changes", and the program crashed...

To ask or not to ask, this is a question. I could either beat myself to death and get stuck while trying to figure things out on my own, or bring up the blockers during standup meetings and seek help from colleagues. The latter is way more effective, and I quickly realized a good question could also be a collective learning experience for other team members. As long as you demonstrate some effort in attempting to resolve the issue independently, you will likely get help instead of being laughed at, because everyone wanted you to succeed. Software engineers are well known for their willingness to help and share knowledge. So there is nothing to be embarrassed about asking a beginner question.

## 04. Master Git Inside Out
Prior to this internship, I learned how to use Git at Collab Lab, but collaborating on a production-level codebase requires Git commands that go beyond the fundamentals. Here are some essential commands I'm using daily:

```
git checkout <branch>
git pull
git add <filename>
git commit -m "commit message"
git push
```
And I'm learning some new ones:
```
git stash
git stash pop
```
Let's say you are on a <feature_branch> and need to quickly switch to <main> branch to address another task, yet there are unsaved local changes. Rather than committing all the changes on <feature_branch>, you could use `git stash` command to save all changes locally to retrieve later.

Here is another handy one:
```
git rebase main
git rebase --continue
```
Imagine you checked out a <feature_branch>, and new changes are being committed on the <main> branch that you want to integrate into the <feature_branch>. You can use `git rebase main` to incorporate the latest changes from <main> to the <feature_branch>.

While Git commands are not rocket science, it is crucial for codebase collaboration and version control. Spend a few days to fully understand each command and create your own cheat sheet, and your future self will thank you later.

## Conclusion
As I navigated through the first few weeks of my internship, moments of self-doubt occasionally crept in, and I couldn't stop wondering if I had the talent to become a job-ready engineer, but because my incremental progress was recognized by my seniors, and I received a tremendous amount of encouragement from colleagues and friends, I am now more ascertain that I am on the right path.

I want to use my favorite quote from British Physicist David Deutsch to conclude my reflection:

> Problems are inevitable, problems are solvable.

Happy coding!