From Scientific Computing to Software Engineering
My interest in programming developed naturally through mathematics and scientific computing. During my academic work, programming became an increasingly important tool for implementing numerical methods, running simulations, and solving computational problems.
My doctoral research strengthened this connection significantly. Working extensively with C++ and high-performance computing showed me that I enjoyed not only the mathematics behind computational problems, but also the process of designing, implementing, debugging, and improving the software used to solve them.
Over time, this interest expanded beyond scientific computing and led me toward software engineering, where programming itself became a central part of my professional work.
Building Software
Moving into software engineering expanded the way I thought about programming. In scientific computing, my primary focus had been using code to solve mathematical and computational problems. Software engineering introduced a broader challenge: building software that is not only functional, but also reliable, maintainable, testable, and understandable by others.
This required thinking beyond individual algorithms and considering how different parts of a software system work together. Debugging, testing, documentation, version control, and writing clean and reusable code became important parts of the development process.
Learning to approach programming from this perspective transformed it from primarily a computational tool into the process of designing and building software that others could use, maintain, and improve.
Programming and Problem Solving
One of the aspects of programming that attracted me most was its similarity to mathematical problem solving. Both require breaking complex problems into smaller components, identifying patterns, reasoning carefully about possible solutions, and refining an approach when the first attempt does not work.
My background in mathematics and research provided a strong foundation for this way of thinking. Programming added another dimension: ideas had to be translated into precise instructions that a computer could execute, while accounting for correctness, efficiency, and unexpected behavior.
Over time, I came to see programming as another language for problem solving—one that allowed me to combine logical reasoning, creativity, and computation to build practical solutions.
Professional Software Engineering
My professional software engineering work expanded my experience beyond scientific computing into broader software development and technical problem solving. I worked on tasks involving software implementation, debugging, testing, documentation, and improving existing code, while gaining experience with the collaborative processes involved in developing and maintaining software.
A significant part of my professional focus has been algorithmic problem solving and technical interview preparation. This included working extensively with data structures and algorithms, analyzing time and space complexity, solving LeetCode-style problems, and helping others develop the problem-solving skills required for technical interviews.
These experiences allowed me to combine the analytical foundation I developed through mathematics with practical software engineering and teaching, strengthening both my programming skills and my ability to communicate complex technical ideas clearly.
Algorithms and Technical Problem Solving
Algorithmic problem solving became one of the areas of software engineering that interested me most. I have spent significant time working with data structures and algorithms, solving programming problems, and developing a deeper understanding of how different approaches affect the efficiency of a solution.
Through extensive practice on platforms such as LeetCode, I strengthened my ability to recognize common problem-solving patterns, select appropriate data structures and algorithms, and analyze solutions through their time and space complexity. The goal was not simply to produce code that worked, but to understand why one solution might be more efficient or scalable than another.
This type of problem solving felt particularly natural to me because of my mathematical background. Much like mathematical problem solving, algorithmic challenges require logical reasoning, creativity, persistence, and the ability to approach the same problem from multiple directions until an effective solution emerges.
What I Learned from Software Engineering
Software engineering taught me that solving a problem is only part of the challenge. A strong solution also needs to be efficient, understandable, testable, and maintainable. Learning to evaluate different approaches and their trade-offs strengthened the systematic way I approach technical problems.
My work also extended into technical interview preparation, where I helped others develop their skills in data structures, algorithms, and LeetCode-style problem solving. Teaching these concepts required more than knowing how to reach a solution myself; I needed to explain the reasoning behind an approach, compare alternative solutions, and communicate time and space complexity clearly.
This combination of building, solving, and teaching reinforced something that has remained central to my professional work: understanding a technical idea deeply enough to both apply it effectively and explain it clearly to someone else.
From Software Engineering to Lifetime Learner
As my experience in software engineering grew, teaching remained an important part of my professional life. Working with students and preparing individuals for technical interviews allowed me to combine two areas I enjoyed: solving challenging problems and helping others understand how to solve them.
Over time, the different parts of my background began to come together. Mathematics provided the foundation for rigorous problem solving, research strengthened my analytical thinking, and software engineering expanded those skills into programming, algorithms, and computational problem solving.
These experiences eventually became part of a broader teaching journey through Lifetime Learner, where I could bring together mathematics, programming, problem solving, and education under one professional direction. This marked the beginning of the next chapter of my journey—not a departure from what came before, but an opportunity to build upon it.