Balancing two jobs while pursuing a computer science degree full-time is not for the faint of heart. For months, I found myself constantly switching contexts, feeling perpetually behind, and watching my productivity suffer despite putting in long hours. That all changed when I discovered the power of structured 4-hour focus blocks.

The Breaking Point

Like many students trying to fund their education, I was working two part-time jobs while tackling a demanding CS curriculum. My schedule was a mess—I’d answer emails from one job while mentally planning projects for another, all while trying to wrap my head around data structures and algorithms. Something had to give.

The 4-Hour Solution

After reading about deep work and time blocking, I decided to restructure my approach entirely. Instead of multitasking throughout the day, I began allocating dedicated 4-hour blocks to each major responsibility in my life:

• 4 hours of uninterrupted coding for coursework
• 4 hours focused solely on Job A
• 4 hours dedicated exclusively to Job B

Why It Works

The 4-hour timeframe isn’t arbitrary. It’s long enough to achieve deep focus and make meaningful progress, but short enough to maintain high energy levels. When I know I only have 4 hours to complete a specific set of tasks, I’m less likely to procrastinate or get distracted.

The psychological clarity is perhaps the biggest benefit. When I’m in my “CS student” block, I’m fully present—not worrying about work deadlines or checking Slack notifications. This single-tasking approach dramatically improved both my productivity and mental health.

Making It Happen

This strategy requires ruthless prioritization and boundary-setting. I had to communicate clearly with both employers about my availability and become extremely protective of my time blocks. I also had to get comfortable saying “no” to spontaneous social invitations that would disrupt my schedule.

What started as a desperate attempt to keep my head above water has become a sustainable approach to achieving multiple goals simultaneously. By giving each part of my life its own dedicated space, I’ve found that I can indeed have it all—just not all at once.

If you could start over, what technologies would you use instead?

For Vocabulous, while React and Tailwind CSS have been excellent choices for the frontend, I would have advocated for Nest.js instead of Laravel for the backend. Nest.js would have provided several advantages:

1. Unified TypeScript ecosystem across frontend and backend
2. Familiar JavaScript/Node.js environment
3. Built-in support for WebSockets and real-time features
4. Easier integration with modern JavaScript tools and libraries

What would you change about any of the technologies you used?

In terms of our current tech stack, I’d make a few adjustments:

For React, I’d consider incorporating more state management patterns from the start. While React’s Context API and local state work well for simpler components, a more robust solution like Redux Toolkit or Zustand could help manage Vocabulous’s growing complexity, especially for features like user progress tracking and vocabulary lists.

With Tailwind, while its utility-first approach speeds up development, I’d establish stricter component-level CSS conventions earlier in the project. This would help prevent duplicate styles and maintain consistency across the application. Perhaps implementing a component library with predefined Tailwind classes would streamline our development process.

The biggest change would be replacing Laravel with Nest.js, as mentioned earlier. This would allow for much better code sharing between frontend and backend, more straightforward API integration, and easier implementation of real-time features that could enhance the vocabulary learning experience.

While our current stack is functional, these adjustments could potentially improve both the development experience and the final product.

When writing functions, it’s tempting to cram multiple operations into one large function. Sometimes deadlines are tight, fatigue sets in, or laziness creeps up. However, this approach makes your code harder to read, debug, and maintain. A good function should do just one thing—and do it well. If a function performs several tasks, it should be broken into smaller functions, each focused on a single responsibility.

Here’s a JavaScript example inspired by Clean Code Handbook (page 302):

function pay(employees) {
  employees.forEach((employee) => {
    if (employee.isPayday) {
      const pay = employee.salary * employee.hoursWorked;
      employee.bankAccount.deposit(pay);
      console.log(`Paid ${pay} to ${employee.name}`);
    }
  });
}

While the function itself is only 9 lines long, it violates the principle of a single responsibility. When a function is written like this, it makes it more difficult to read, refactor, and test. 

function pay(employees) {
  employees.forEach((employee) => processPayment(employee));
}

function processPayment(employee) {
  if (isPayday(employee)) {
    const pay = calculatePay(employee);
    deliverPay(employee, pay);
    logPayment(employee, pay);
  }
}

function isPayday(employee) {
  return employee.isPayday;
}

function calculatePay(employee) {
  return employee.salary * employee.hoursWorked;
}

function deliverPay(employee, amount) {
  employee.bankAccount.deposit(amount);
}

function logPayment(employee, amount) {
  console.log(`Paid ${amount} to ${employee.name}`);
}

Benefits of Smaller Functions

Breaking down functions into single-responsibility components provides several advantages:

1. Improved Readability

Each function is short, descriptive, and easy to understand. You don’t need to wade through the logic to figure out what calculatePay or deliverPay does. Their purpose is clear from their names.

2. Easier Maintenance

When a requirement changes—say, you need to update how payments are logged—you can modify just the logPayment function without affecting the rest of the system. This reduces the risk of introducing bugs elsewhere.

3. Simpler Testing

Testing smaller functions is much easier than testing a monolithic one. You can write unit tests for isPayday, calculatePay, or logPayment independently, ensuring that each part of your application works correctly.

4. Separation of Concerns

By dividing responsibilities, you make your code modular. This modularity allows you to isolate logic, leading to better architecture and long-term scalability.

Conclusion

Clean, maintainable code is not about adding more lines; it’s about structuring those lines intelligently. Writing functions that do one thing is a fundamental principle of clean code, and it pays off in readability, maintainability, and testability.

Next time you’re tempted to write an all-in-one function, pause and ask yourself: Can this be broken into smaller functions? The answer will likely lead to cleaner, more efficient code.

Happy coding!

This week marks a new chapter in my startup journey: I’m transitioning from my role building incorporation forms on our frontend to being the on-call engineer. After months of crafting user interfaces and streamlining the entity formation process, I’m stepping into a position that puts me on the front lines of our production environment.

Between my usual coursework and TA responsibilities, I’ll be the first line of defense for our system’s health. The role brings its own unique rhythm – constant monitoring of performance dashboards, swift responses to alert pings, and detailed documentation for our senior engineers. Each notification could mean a critical bug needs fixing or a performance bottleneck needs addressing. It’s quite different from designing form validations and optimizing user flows, but it’s teaching me the real-world implications of every line of code we push to production.

The same discipline that helps me juggle my CS courses and TA duties comes in handy now. Every alert is a learning opportunity, every incident report a chance to deepen my understanding of our systems. While I’ll miss the satisfaction of seeing new features come to life in our incorporation workflow, there’s a different kind of fulfillment in ensuring our entire platform runs smoothly for users across the globe.

Time to prepare for standup and another day of keeping our services running smoothly. The metrics look stable for now, but in this role, you never know what the next notification might bring.

Cheers

Introduction

It’s 4 AM, and the morning light begins to illuminate my single-room Airbnb as I finish my final tasks for the day. I have to be back up and ready to go by 10 AM, where I’ll be joining the Engineering Team for morning standup at the office where I currently live: Bangalore, India. After coding into the late evening, I will switch to tackling the never-ending list of tasks listed under my Canvas “To Dos”, and will once again be greeted by the early morning light as I close my eyes.

The Foundation: Life as a CS Student

Four computer science courses might sound like a full plate on their own – and they are. From diving into the intricacies of programming language fundamentals (CS381) to wrestling with the complexities of sockets in CS406, running to virtual meetings with my senior engineering capstone team (CS461), to experimenting with code labs involving cryptographic functions and security (CS370), my brain is constantly processing complex technical concepts. Each course demands its own headspace, projects, and dedication. The silver lining? The technical foundation I’m building serves as a backbone for everything else I do.

Teaching to Learn: The TA Experience

There’s something magical about teaching concepts you’re still mastering yourself. As a TA for a computer science course, I’ve discovered that explaining database fundamentals to struggling students has deepened my own understanding exponentially. Every question from a student is an opportunity to revisit the basics and see them through fresh eyes. Plus, the experience of mentoring others has improved my communication skills – and is truly its own reward.

The Global Startup Adventure

My internship with a B2B startup that facilitates cross-border entity incorporation has opened my eyes to the intersection of technology and international business. Working with a team in India means long hours and cultural learning opportunities I never expected. The real-world applications of technology in solving complex business problems provide context to my academic work, while my coursework helps me understand our technical challenges more deeply.

The Art of the Juggle

Being in Bangalore while maintaining my academic responsibilities back home requires a carefully orchestrated schedule. Here’s my playbook:

• Time Zones are Everything: Living in India means my day starts with my startup work, while my evenings and nights are dedicated to classes and TA sessions back home. Those precious hours in between? That’s when I tackle assignments and course projects.
• Finding Flow: Each role feeds into the others in unexpected ways. The algorithmic thinking from my coursework helps me optimize our startup’s processes; my TA experience makes me a better team communicator; the real-world coding challenges at work bring my coursework to life.

The Unexpected Growth

Living this triple life has taught me more than I expected:

• The 12.5-hour time difference has made me incredibly efficient with my time
• Teaching database concepts remotely has honed my ability to explain complex ideas simply
• Working in India has taught me to be adaptable and resilient in ways no classroom could
• Juggling these roles has shown me that I’m capable of more than I imagined

Looking Ahead

As I reach the midpoint of this journey, exhaustion and excitement dance together daily. The second half brings new challenges: final projects looming in all four courses, my TA students preparing for their final project deadlines, and increasing responsibilities at the startup. But now that I have a rhythm, my confidence has risen to meet these new challenges.

To anyone considering taking on multiple roles across multiple time zones: yes, it’s intense. Yes, you’ll question your decisions at 4 AM. But if you’re passionate about each piece, the symphony they create together is worth the challenging orchestration.

The increasing shadow on the wall from the setting sun in my Bangalore window reminds me it’s time to break away from screens and hit the gym. Now, if you’ll excuse me, my trainer, Bibin Babu, awaits me.

Introduction

Hello, I’m Devin! I’m a senior at Oregon State University, pursuing a B.S. in Computer Science. I’ve always been interested in technology, from taking apart remote control cars as a child to building websites and apps in my free time as an adult. My goal is to gain experience scaling SaaS businesses and eventually build a startup.

Timezone and/or location

Currently located in Bangalore, India (IST)

Kids, pets, hobbies, sports, games, activities, shows, etc

No kids but would like to have 2 daughters some day. Currently in a grind period of life, so don’t find myself with much time for hobbies. But when I am not studying or working, I am either at the gym, learning Spanish, or listening to podcasts. My favorite shows are The Wire and Californication.

What got you started with computers or software?

Engineering runs in my family—my grandfather was a mathematician and mechanical engineer, and my uncle is a software engineer. I’ve always been fascinated by how technology can transform reality and improve life in countless ways.

Your journey with OSU I began my educational journey as Lane Community in Eugene, Oregon. From there, I transferred into OSU as a Junior in 2022.

Current job or internship

I haven’t had an official job as a software engineer yet, but I recently started an internship at Commenda, a SaaS company that assists with entity incorporation and tax compliance. They are a Seattle-based company with a home office in Bangalore, India, where I currently reside.

Favorite technologies

I’m particularly passionate about web development, with Next.js, Nest.js, and React being my favorite tools. I enjoy using Next.js for its seamless integration of server-side rendering, making web applications efficient and scalable. I enjoy working with Nest.js for its support building server-side applications with TypeScript. Together, these technologies enable me to quickly build full-stack applications with a focus on performance, scalability, and buttery UX.

Favorite listed projects (in this course) and why

I’m particularly excited about exploring LLM’s at the edge, as well as my own project proposal to create a language learning vocabulary app. Being passionate about Spanish, I’ve noticed many of the existing tools in this space are lacking in effectiveness. I’m thrilled at the opportunity to collaborate and build a fully-fledged app as a team, addressing these gaps and providing a more engaging and effective learning experience.