Tech stacks are constantly evolving, but the rate at which they evolve is directly impacted by how quickly a dev team can master new languages, frameworks and databases. Given that speed is the goal, this learning often takes place on the job as opposed to in a safe sandbox. Learning on the job where mistakes have real consequences can be stressful — but it doesn’t have to be.
At quantum computing company IonQ, a culture that values collaboration and autonomy helps take the pressure off of learning new languages. Cori Williams, a software engineer, told Built In Seattle that detailed code reviews with her colleagues at IonQ were incredibly helpful in learning Go while on the job. In addition to receiving help from her peers, Williams was given the space to learn and make mistakes while working on her own large-scale projects. This reinforced the idea that while what she was learning was crucial to the business, the expectation was indeed to learn, not be perfect.
According to Williams, this approach has helped make it easier to learn Rust, which she is currently using for a new project. She took some time off from coding to talk to Built In Seattle about IonQ’s approach to helping engineers improve their code-writing skills on the job along with her advice to new devs who want to become better at learning by doing.
IonQ builds quantum computing hardware and cloud software. Cori Williams joined the company in June of 2020 as an intern for three months and accepted a role as a software developer in August of 2021. Since coming on full time, Williams told Built In Seattle her coding skills have improved thanks to help from her colleagues, a willingness to ask questions and from being unafraid to follow her instincts.
How have your code-writing skills improved since joining IonQ, and how did the company help facilitate that improvement?
Learning a programming language is a lot like learning any other language: You can be proficient enough to write it, but the real power comes from being so comfortable that you start thinking in that language and can point out mistakes based on nothing more than a gut feeling. I’m not quite there yet with Go, but in building this skill I’ve found code reviews by other engineers incredibly helpful. This is especially true when reviews come from engineers who are willing to spend time pointing out little issues and explaining why they’re important. Over time it’s started to sink into my own thinking.
While code reviews are useful, I’ve also learned it’s important to follow your own instincts — and in turn to learn from your own mistakes — rather than always following others’s advice. There is rarely one right way to design a software system, so it’s most important to choose a route you’re comfortable implementing and maintaining. At IonQ, I’ve been grateful to own larger-scale projects early on in my career. Through this I’ve made mistakes, learned better alternatives and applied those patterns to my next design.
It’s important to follow your own instincts — and in turn to learn from your own mistakes — rather than always following others’s advice.”
Tell us about a project that you completed thanks to your leveled-up code skills.
I just finished working on the initial prototype for our internal research platform. Because I had developed better instincts in Go, I was able to write more robust code and refactor my old, error-prone code. The project was better tested than anything I had worked on previously and thus had a smoother launch when it was deployed to initial users. It’s also better documented, so other engineers could work on the project with me.
I’m now coding in Rust, a much lower level language, to build a part of our quantum program compilation pipeline. I’m able to pick up faster on what’s idiomatic in Rust because I recently had to go through the same process in learning Go. The two languages are very different, but the skill of internalizing advice and articles to figure out best practices still applies.
In this project I’ve also had the chance to put my design skills to the test as it’s the first project I’ll build from start to finish. I’ve really enjoyed getting to work with other engineers and hearing their thoughts on how we should design this software. I’m still learning to follow my own instincts in Rust, but I’m excited to be the lead on a project with this much complexity.
For engineers just starting out, how can they best improve their code-writing skills while on the job?
To me, this is a multi-step process.
Step one: When interviewing, try to figure out if the company is a collaborative place where you’ll feel comfortable learning. Your first job is a lot more about who you work with than what you do.
Step two: Accept your neophyte status. Forgive yourself for not knowing all the answers and get excited to learn them!
Step three: Ask a ton of questions. If someone suggests something in your code review, ask why. If someone chooses one framework over another, ask why? What does that tool do? Why do we set up our environments that way? What part of this testing infrastructure is ideal and what should we improve?
Step four: Once you feel more comfortable, dive into a project and ask for help when you need it. When you do ask for help, summarize what you’ve been thinking so far so people know you’ve tried to solve the problem.
Step five: Read articles about best practices in the language you’re using. If something feels weird about your code, research better patterns. This can be a great way to build intuition on your own.
You have to be kind to yourself and take the time to learn what you need. It’s the most challenging part of being an engineer, but it’s also what keeps work exciting.
