Reflections on Final Year Projects in Computer Science: From Basic Chips to Abstract Programming
As a recent graduate in Computer Science, my final year project provided a deep dive into the realm of field cable-run optimization for railway signalling projects. This conversion from a mathematical background to software engineering was both challenging and enlightening. What I eventually realized was that traditional final year projects might not adequately prepare students for real-world programming challenges.
From Maths to Software Engineering
My transition from a maths graduate to a software engineering student involved a practical project that developed a field cable-run optimization tool for railway signalling. This project taught me about practical application and the intricacies of software development in an industrial setting. While practical, it paled in comparison to the theoretical insights gained during my honours thesis.
Honours Thesis: Implementing a C Machine in Burroughs B1700 Microcode
My honours thesis involved implementing a C machine in Burroughs B1700 microcode. This project was a journey into understanding the inner workings of a computer from the lowest levels of hardware to the programming language level. It reinforced the idea that machines operate in a fetch-decode-execution cycle, highlighting the importance of exposing the right aspects at the programming level. The thesis also underscored the necessity to abstract complex operations away from the programmer, which is why high-level languages like C, despite their features, are still too low-level for most software development.
Abstract Programming and Machine Perception
What I found most striking was how the project taught me to appreciate abstraction in programming. Just as no one should directly program in assembly, abstracting complex machine operations into high-level languages enhances productivity and maintainability. This experience highlighted the importance of building a solid understanding of abstraction before delving into the details of machine hardware.
Challenges in Modern Computer Science Education
Today’s students are often deprived of the experience of building a system from the ground up, a skill that I believe is still essential. While certain aspects of building from the bottom may not be necessary, understanding the foundational principles of abstract programming independent of hardware intricacies is crucial. However, mastering the mechanics of how computers work can greatly solidify this understanding, unless students are misled into thinking that low-level programming is the essence of real programming.
Building Machines from the Ground Up
Alan Kay’s philosophy of building machines from the ground up aligns with my experiences. This approach integrates hardware and software more closely, designing the hardware to support the abstract notions of software. This paradoxical process can result in hardware that is more independent from specific underlying hardware designs, leading to more robust and adaptable software.
Champions of Ground-Up Design
Rewinding to Robert Barton and Niklaus Wirth: Both strongly advocate for building systems from the ground up. Barton criticized the trend of designing processors and instruction sets without considering secure multiprogramming needs. Wirth, on the other hand, used Field-Programmable Gate Arrays (FPGAs) to develop custom architectures that better supported his language innovations.
Conclusion: Final Year Projects and the Future of CS Education
Perhaps more final year projects should incorporate building systems with basic chips like FPGAs. This would provide a more comprehensive understanding of the hardware-software connection and the importance of abstraction in programming. Our goal should be to achieve true software independence, not just through abstraction but by thoroughly understanding the underlying hardware.
Reconnecting students with the fundamental principles of computer science can better prepare them for the challenges of the future. As we move forward, let’s ensure that the next generation of computer scientists grasps both the abstract and the concrete, forging a path that blends the two for a more integrated and adaptable computing landscape.