Computer science has often been portrayed as a field where only a select few can succeed. Yet decades of research in computer science education suggest something far more encouraging: student success in computing is strongly influenced by how we teach, how students are supported, and how learning environments are designed. When instruction aligns with research-based practices, student learning and persistence increase across experience levels. One of the most consistent findings across STEM education is the effectiveness of active learning. A large meta-analysis by Freeman et al. found that students in active-learning environments performed better and were significantly less likely to fail than students in traditional lecture-only courses (Freeman et al., 2014: https://www.pnas.org/doi/10.1073/pnas.1319030111). In computer science, active learning includes structured labs, guided coding exercises, peer discussion, and opportunities for students to reason through problems. Programming is a skill developed through practice, iteration, and feedback—not passive observation. Research also emphasizes the role of self-efficacy, or students’ belief in their ability to succeed. Albert Bandura’s foundational work shows that confidence influences persistence, motivation, and academic performance (Bandura, 1997: https://www.uky.edu/~eushe2/Bandura/BanEncy.html). In computing, studies indicate that students who believe success comes from effort and effective strategies—rather than innate talent—are more likely to continue in the major (Lewis et al., 2016: https://dl.acm.org/doi/10.1145/2839509.2844593). Early, well-scaffolded successes and explicit normalization of struggle, particularly around debugging, help reinforce this belief. Collaborative learning further supports student success. Research on peer instruction and pair programming demonstrates improvements in conceptual understanding and student engagement, especially in introductory computer science courses (Porter et al., 2013: https://dl.acm.org/doi/10.1145/2445196.2445248). Working with peers helps students articulate their thinking, learn from alternative approaches, and develop communication skills central to professional computing practice. From a cognitive perspective, worked examples and scaffolding are especially effective for novice programmers. Cognitive Load Theory shows that learners benefit from studying annotated or partially solved examples before tackling problems independently (Sweller, 1988: https://link.springer.com/article/10.1007/BF00375144). As students gain expertise, these supports can be gradually removed. Finally, real-world and challenge-based projects increase motivation by helping students see computing as relevant and impactful. When students understand why their code matters, they engage more deeply and persist longer. The message from the research is clear and hopeful: computer science students thrive when instruction is intentional, supportive, and evidence-based.

For most of my 30 years as a software developer, writing code meant opening an editor, thinking deeply about the problem, and manually translating ideas into syntax. I took pride in understanding every line, every semicolon, every object. My workflow was built around careful planning, debugging, refactoring, and hours spent in documentation. That approach shaped generations of developers — including me. But today, tools like GitHub Copilot and Claude Code are reshaping what it means to write software, and even for veterans like me, it’s clear that resisting these tools is a mistake. Copilot and Claude Code represent the rise of AI-assisted development — an evolution, not a replacement, of our profession. Both tools act like highly skilled pair programmers who sit beside you, offering suggestions, generating boilerplate, and even creating entire functions or modules from a simple comment. Copilot excels at in-editor code completion and pattern recognition, while Claude Code brings the power of large context windows, multi-file reasoning, and project-wide refactoring. For someone who grew up writing everything manually, the speed and accuracy of these tools can feel almost disruptive. But that disruption is precisely why traditional developers should take notice. The contrast between traditional coding and AI-assisted coding is stark. Traditional coding demands concentration, time, and a deep mastery of syntax. AI-assisted coding shifts the focus from keystrokes to concepts. Instead of writing everything by hand, developers now guide the AI with clear intent: “Build me a REST API,” “Refactor this module,” or “Explain why this function fails on edge cases.” The developer becomes more of an architect — defining the blueprint while the AI handles the scaffolding. Some worry that these tools will weaken foundational skills. I see the opposite: by offloading repetitive work, Copilot and Claude allow developers to spend more time on architecture, design, problem-solving, and understanding user needs. The core of our craft — thinking clearly about systems — becomes even more important. A traditional developer would be wise to adopt these tools now for a simple reason: AI-assisted coding is quickly becoming the industry standard. Teams that use them deliver faster, iterate more confidently, and reduce the mental load of repetitive tasks. Learning to code with AI is not about abandoning the fundamentals — it’s about amplifying them. The developers who thrive in the next decade will be those who blend traditional craftsmanship with AI-powered acceleration. Embracing Copilot and Claude isn’t about keeping up with the future. It’s about helping to build it.

Every few years, someone announces that a new technology is finally going to eliminate the need for computer programmers. I smile every time I hear it. After more than 30 years as a software developer and now as a professor of computer science, I’ve watched this prediction come and go like clockwork. Each new wave arrives with bold promises, confident headlines, and enthusiastic believers. And yet—here we are. Not only are programmers still here, but the demand for them has also grown. I remember when COBOL and FORTRAN were supposed to allow business leaders to write their own software. Then came the fourth-generation languages in the 1970s and 80s, marketed as tools that would let end users build applications without any programming knowledge. In the 90s, CASE tools claimed that we could draw diagrams and have the system generate perfect code. Later, web design software like FrontPage and Dreamweaver promised that anyone could create a website with no developer required. More recently, low-code and no-code platforms were supposed to empower “citizen developers” and make professional programmers obsolete. Today, AI has taken center stage as the latest technology hailed as the end of programming as we know it. I hear students and professionals alike anxiously asking whether AI will replace their future careers. Every single time, the pattern repeats. What actually happens is that the new technology lowers the barrier to entry and expands what’s possible. Businesses realize they can build more software, automate more processes, reach more customers, and integrate more systems. Complexity increases, expectations grow, and suddenly we need more programmers, not fewer. The work shifts, but it doesn’t disappear. The misconception driving these predictions is the belief that programming is simply typing code. Anyone who has spent real time in this field knows better. Programming is problem solving. It’s abstraction and modeling. It’s understanding people and processes. It’s designing systems that will be secure, maintainable, ethical, and resilient. The code is just the vehicle. AI can generate code, and that’s impressive. It can accelerate development and reduce rote work. But AI does not understand the problem domain. It does not negotiate requirements, collaborate with stakeholders, or anticipate the real-world consequences of technical decisions. Someone still has to think critically, architect solutions, and ensure that what we build serves people well. As I tell my students: tools evolve, but the need for human creativity, judgment, and responsibility remains. AI won’t eliminate programmers. It will transform what programming looks like—and in many ways, make it even more important. The future belongs to those who can think computationally, ethically, and imaginatively. That’s not going away anytime soon.

last week, I had the privilege of presenting at the Faculty and Staff of Students of Color Conference in Vancouver, Washington. The theme of my session, From Lagos to the Lecture Hall: Carrying Ancestral Knowledge into the Future of Higher Education, is one that continues to live inside of me even after the conference ended. I spoke about my recent journey to Lagos, Nigeria—an experience that was much more than travel. It was a return. A listening. A remembering. Standing in Lagos, I felt the ground beneath my feet differently. The air, the rhythm of the city, the way the people moved with purpose and ease—everything reminded me that before we were faculty, before we were employees, before we were measured by productivity or credentials, we were rooted in something far older. We come from people who innovated, created, organized, resisted, and built community long before higher education existed. Our ancestors understood knowledge not just as information, but as relationship—to land, to family, to spirit, and to purpose. As educators of color, we often walk into institutions carrying histories that are invisible to the systems we move through. Yet those histories shape how we teach, how we lead, and how we show up for students. In Lagos, I was reminded that our work is not only intellectual—it is ancestral. It is guided by voices and lessons that did not need to be written down to be real. At the conference, I encountered colleagues who deeply understood this. We shared stories of resilience, joy, fatigue, hope, and the ongoing journey of making space for authenticity in environments that sometimes struggle to hold it. There was laughter. There were nods of recognition. There was restoration. What I brought back with me—and what I offered in my presentation—is this: We do not walk into the classroom alone. Our ancestors walk with us. Their creativity is in our problem-solving. Their courage is in our leadership. Their love is in our mentoring. When we remember this, we teach differently. We lead differently. We live differently. As I return to my lecture halls, I am carrying Lagos with me—not as a place I visited, but as a home I remembered. And I am committed to ensuring my students remember too.

In today’s fast-moving world of software development, it might seem tempting to skip over traditional programming paradigms like object-oriented programming (OOP) and head straight into newer trends like functional programming, data-driven frameworks, or AI tooling. However, OOP continues to be a critical skill that aspiring software developers should master. Object-oriented programming, at its core, is about modeling software systems around “objects” that represent real-world entities. This approach, which emphasizes encapsulation, abstraction, inheritance, and polymorphism, has been the foundation of most enterprise applications for decades. Whether you are working in Java, C++, C#, or Python, OOP principles show up everywhere. Even if you never create your own elaborate class hierarchies, understanding how objects interact is key to working with frameworks, libraries, and APIs that dominate modern development. One of the main reasons OOP remains important is that it teaches developers how to think about software design. It enforces structure and modularity, making systems easier to maintain and scale. For instance, when designing a large application like an e-commerce platform, OOP concepts help developers break down the system into manageable components: products, users, orders, and payment modules. Each of these components can evolve independently while still interacting through well-defined interfaces. OOP also supports the collaborative nature of modern software development. Teams can work on different parts of the codebase with minimal overlap, which is essential for building complex systems across industries such as finance, healthcare, and education. Even experts in programming education recognize its enduring relevance. In his book Code Complete , Steve McConnell emphasizes that, Good object-oriented design makes code more understandable, more maintainable, and less error prone. This insight highlights why OOP continues to be taught in nearly every computer science curriculum — it fosters long-term skills that apply regardless of language or framework. Of course, OOP is not the only paradigm developers need to know. Functional programming, declarative approaches, and event-driven systems are all valuable tools. But a strong grounding in OOP provides a solid mental model that makes it easier to pick up these other paradigms later. For aspiring developers, the message is clear: learn OOP, master its principles, and then branch out. OOP may not dominate every cutting-edge domain, but it is still a cornerstone of professional software development — and will continue to be for years to come.

One of the most exciting aspects of working in technology is also one of its greatest challenges: change is constant. New frameworks, languages, and tools appear every year, often promising to make development faster, cleaner, or more powerful. With so many options, it’s tempting to pick a favorite and hold onto it like a badge of honor. But while having preferences is natural, becoming “religious” about technology—treating one tool as superior in all circumstances—can limit growth and opportunity. John Sonmez, author of The Complete Software Developer’s Career Guide (2017), explains this pitfall clearly: “Too many developers get religious about their tools”—treating languages, frameworks, or methodologies as the only right way. He warns that this mindset not only creates unnecessary division but can also stall a career and prevent real growth. Technology is constantly evolving. The tools that dominate today may be outdated tomorrow. For example, COBOL once ruled enterprise systems, yet many new developers have never touched it. More recently, frameworks like AngularJS gave way to React and Vue, while artificial intelligence and cloud computing are reshaping entire industries. If a developer ties their identity too strongly to a single language or platform, they risk being left behind when the industry shifts. Instead of devotion to one technology, developers should cultivate adaptability. Being flexible allows you to evaluate each project on its own merits and choose the best tool for the job. This not only makes you more effective, but also more valuable in the job market. Employers seek problem solvers who can navigate multiple ecosystems, not zealots who refuse to look beyond their comfort zones. As Sonmez reminds us, technology is just a tool—nothing more. A good carpenter doesn’t obsess over one hammer; they master the entire toolbox. Likewise, a good developer learns multiple languages, frameworks, and practices, always keeping in mind that the end goal is solving problems and creating value for people. Ultimately, resisting the urge to be religious about technology fosters collaboration, humility, and continuous learning. It keeps us focused on what matters most: writing software that improves lives, businesses, and communities. In the end, your greatest strength as a developer is not your loyalty to one stack, but your ability to adapt, learn, and deliver results in a world of constant change.

The technology industry has long been seen as a place of innovation, ambition, and opportunity. Yet behind the glossy exteriors of glass-walled campuses and cutting-edge projects lies a growing concern: the human toll of relentless workloads and high-pressure environments. Recent tragedies remind us that unchecked stress can have devastating consequences, especially as layoffs compound the demands placed on those who remain. In 2016, Joseph Thomas, a 33-year-old software engineer at Uber, took his own life just months after joining the company. His family attributed his decline in mental health to Uber’s crushing work culture. Medical records revealed anxiety, insomnia, and panic attacks, while messages to friends showed how deeply the pressure had broken his spirit. Despite his talent and potential, Thomas felt trapped, unable to summon the energy to look for another job. His story is a haunting example of how toxic work conditions can overwhelm even the most capable professionals. Fast forward to August 2025, when Pratik Pandey, a 35-year-old Microsoft engineer, was found dead on the company’s Silicon Valley campus in the early hours of the morning. The medical examiner cited a heart attack, but his family believes long nights and unrelenting stress played a role. Pandey had reportedly worked extended hours for weeks on end, often staying at the office late into the night. His death has sparked a renewed debate about burnout, exhaustion, and the hidden costs of tech’s “always-on” culture. These cases underscore a reality many in the industry know well: layoffs and cost-cutting measures often leave fewer people to do the same amount of work—or more. Engineers, developers, and other staff find themselves stretched thin, juggling multiple projects, fearing mistakes, and quietly battling fatigue. While companies reap short-term savings, employees shoulder the burden in ways that can damage their health and wellbeing. So, what can employees do to reduce the stress that comes with these demanding jobs? While systemic change at the organizational level is crucial, there are also practical steps individuals can take: 1. Set Boundaries: Resist the expectation to always be available. Logging off at a consistent time, avoiding unnecessary late-night emails, and carving out protected personal hours are vital for recovery. 2. Prioritize Health: Stress often manifests physically. Regular exercise, proper sleep, and balanced nutrition are not luxuries—they’re essential defenses against burnout. 3. Seek Support: Talking to a therapist, counselor, or trusted colleague can help lighten the mental load. Many companies have Employee Assistance Programs (EAPs) that provide confidential resources. 4. Focus on What’s Controllable: Work will always have pressures but reframing how you respond can reduce the weight. Identifying top priorities each day and letting go of less critical tasks can prevent feeling overwhelmed. 5. Advocate for Change: Speaking up—whether by joining wellness initiatives, pushing for realistic deadlines, or simply normalizing conversations about stress—helps build a healthier workplace culture. Ultimately, these tragedies serve as a sobering reminder: no job is worth a life. As the tech industry continues to evolve, companies must recognize that productivity cannot come at the expense of people. Employees, too, must protect their wellbeing with the same vigilance they bring to their code, projects, and innovations. Because at the end of the day, health and humanity matter far more than deadlines or deliverables.

As the fall term begins, students everywhere are experiencing that familiar mix of excitement and uncertainty that comes with returning to school. Whether you are stepping onto a college campus for the very first time or continuing a program you have already started, this moment represents more than just the start of another academic year. It is an opportunity to reset, refocus, and build momentum toward your goals. As a computer science professor, I’ve seen how students can transform their experience when they approach the year with both intention and curiosity. Success in school is not just about passing exams or finishing assignments—it’s about building the habits, relationships, and resilience that will sustain you long after graduation. One of the most powerful things you can do right now is to commit to time management. In computer science especially, assignments can quickly pile up if you leave them to the last minute. Break projects into smaller steps, use a calendar or task manager, and set aside regular study time. Treat your learning the way a software engineer treats a major project: plan it, break it down, and keep iterating. Equally important is community. Too often, students see education as a solo journey. The truth is that learning happens best when it is shared. Form study groups, reach out to classmates, and don’t hesitate to ask questions. Use office hours as a resource. The networks you build here will often become the professional networks that open doors in the future. This year is also a chance to embrace a growth mindset. Computer science can be challenging, and it’s normal to feel stuck at times. Instead of seeing setbacks as failures, treat them as debugging opportunities. Every bug you fix—whether in your code or in your study habits—moves you closer to mastery. Finally, remember that school is not just preparation for a career; it is preparation for life. The discipline, creativity, and problem-solving skills you sharpen here will serve you in any field. So, as you return to your classes, bring with your curiosity, resilience, and the willingness to engage fully with the process. Here’s to a year of discovery, persistence, and growth—inside and outside the classroom.

A recent New York Times article highlighted a troubling reality for computer science graduates: many are struggling to land jobs despite holding degrees from respected programs. Unemployment rates for CS majors are now higher than for fields such as biology or art history, and stories of graduates applying to thousands of positions with little success are becoming increasingly common. The old belief that a computer science degree was a golden ticket to Big Tech has unraveled, especially as artificial intelligence begins to automate entry-level coding tasks and the industry continues to see layoffs and hiring freezes. So, what can these graduates do to adapt to this shifting landscape? While the road is undeniably harder, opportunities remain for those willing to rethink their strategies. Here are six key steps to consider: 1. Differentiate Beyond Coding: Graduates should move past the idea that coding alone is enough. Specializing in areas like cybersecurity, cloud infrastructure, or embedded systems can open doors. Pairing technical skills with knowledge of other fields, such as finance or healthcare, can also create valuable career niches. 2. Build a Strong Portfolio: Employers want evidence of skills in action. A GitHub filled with open-source contributions, small apps, or well-documented projects shows initiative and capability. Demonstrating the ability to use AI tools effectively is another way to stand out. 3. Network Intentionally: The hidden job market is real. Building relationships through meetups, LinkedIn, alumni groups, and professional associations can often lead to opportunities that aren’t posted online. A strong mentor can be a game-changer. 4. Upskill Strategically: Industry certifications in cloud computing, security, or data can make a resume more competitive. Short courses in AI integration or data engineering can help graduates align with emerging employer demands. 5. Explore Alternative Entry Points: Mid-sized firms, nonprofits, government agencies, and startups may not have the brand prestige of Big Tech, but they offer meaningful growth. Contract and freelance work can also provide valuable experience while building credibility. 6. Embrace Resilience: The process may take longer and require more creativity than in the past, but persistence pays off. Tracking progress, applying strategically, and leaning on community support can make the journey less isolating. The tech job market is not disappearing—it is transforming. By showcasing real work, networking with purpose, and continuously adapting, today’s graduates can still thrive in a future where problem-solving, creativity, and cross-disciplinary skills matter as much as code.