Wrapped up Fall Quarter at UCSC!
Writing this during winter break right after wrapping up finals last week.
This quarter was pretty intense but also one of the most rewarding so far. I dove into classical machine learning systems and deep neural networks, and built two projects: CodeCompass and a chess engine.
Academic
I took 3 upper-div classes this quarter: Machine Learning (CSE 142), where I learned the fundamentals of classical ML, Introduction to Software Engineering (CSE 115A), a team-based class designed to teach how to build well-engineered software systems, where we focused on practices like Scrum along with requirements analysis, design, development, testing, and project management, and Collaborative Research Experience in Engineering (CMPM 118), which focused on deep learning techniques and a “research” project.
CSE142 — Machine Learning
About the class:
This class gives an introduction to various ML algorithms, ranging from a humble perceptron to the cutting-edge deep neural networks!
The ML models covered:
- Linear Regression
- Logistic Regression
- Perceptrons
- SVMs
- Naïve Bayes Classifiers
- K-NN
- Decision Trees
- K-means Clustering
- Gaussian Mixture Models
- Markov Models
- Deep Neural Networks
(We also covered ensemble methods and boosting)
There was also a strong focus on language modeling — we built n-gram language models in class, and then for our final project, we trained our own neural language model!
My thoughts on the class:
A 10/10 experience. Prof. Alex Rudnick is an excellent lecturer, and I’m planning to take his graduate NLP and MT course next quarter.
CSE115A — Introduction to Software Engineering
About the class:
While the course covers the full lifecycle of building well-engineered software systems, the main focus was on developing software in a team setting and following industry practices like Scrum. We worked in a team of six for 8 weeks, where I took on the role of Product Owner, helping guide the project’s direction and priorities. CodeCompass was born.
My thoughts on the class:
I came into this class dead set on building a real product. I had just finished an internship at Chelsio Communications where I worked on an internal RAG system, and I wanted to build something of my own using everything I had learned. This class finally gave me the push I needed. The structure, deadlines, and team setting forced me to stop overthinking and just start building an MVP.
Working in a team was a completely new experience for me. As the Product Owner of a six-person team, I was responsible for guiding the vision of CodeCompass. Early on, I underestimated how challenging team dynamics and coordination could be. Work distribution was uneven at times, and I took on more than I could realistically handle, which led to burnout midway through the quarter. Over time, I learned the importance of delegation, trust, and maintaining consistency, especially when other coursework started piling up.
One of my biggest mistakes was not taking version control seriously. Coming from solo projects, I underestimated how important clean branching and integration practices are in a team setting. This led to a messy and painful merge process later on, which was a hard but valuable lesson.
I was also initially skeptical of Scrum and documentation, seeing them as secondary to “real work.” By the end of the quarter, that perspective completely changed. Poor planning and lack of structure caught up with us, and I realized how essential these practices are for managing complexity and keeping a team aligned.
Technically, I was also introduced to building backend APIs using FastAPI, which gave me more hands-on experience designing and writing endpoints. Towards the end of the course, I was also introduced to Claude Code, an agentic coding tool some of my teammates were using for inhuman levels of productivity. I personally stuck to writing code the “old-fashioned” way, using tools like ChatGPT and DeepSeek more as intelligent search engines rather than full coding agents.
Overall, this class was one of the most impactful experiences I’ve had. It taught me not just how to build software, but how to work with others, manage responsibility, and actually follow through on ideas instead of just talking about them.
Keep a look out for CodeCompass, I plan on deploying it sometime in the future 😉
CodeCompass Landing Page
CodeCompass Backend Inference Architecture
CMPM118 — Collaborative Research Experience in Engineering
About the class:
This class serves as the first course in a research “educational track” that prepares students for joining research groups such as the Neuromorphic Computing Group. The course focused on deep learning fundamentals along with a quarter-long group project, where we built a chess engine. Throughout the class, we implemented key neural network architectures from scratch, including feedforward neural networks, convolutional neural networks (CNNs), recurrent neural networks (RNNs), and transformers.
My thoughts on the class:
Building everything from scratch was eye-opening and removed a lot of the mystery around what often feel like “black box” models. This class also complemented my Machine Learning course well, with considerable overlap in material, especially toward the end.
The chess engine project was okayish overall. I don’t think I had enough deep learning knowledge at the time to fully take advantage of it, but it was still a valuable experience. I’ll probably build my own chess engine again in the future, most likely from scratch, to really test my understanding.
Chess Engine Architecture
Life & Other
Gym progress
Decent quarter when it comes to gym progress, but definitely doesn’t even come close to the rigorous routine I was running in the summer.
From Hevy
LeetCode progress
🤫
Chess progress
I attended chess classes twice a week and played basically whenever I could. Road to 2000…
From Chess.com