Attention all students! Make managing your virtual hackathon events even easier with the new Hackathon in the Cloud Experience.
If you’re looking for a real-world approach to computer science education in Germany, you can find it at the Hasso Plattner Institute (HPI) in Potsdam, which offers a practical and engineering-oriented alternative to conventional computer science programs.
In one of HPI’s undergraduate software engineering courses, researchers Arian Treffer and Christoph Matthies encourage their students to make mistakes, assess where they get stuck, and reflect on their software development process. This way students learn how to deliver the best possible results when working together.
The final year undergraduate course “Software Engineering II” features a real-world software development challenge: 20-30 participants jointly develop a single system. Students form small development teams and coordinate within as well as with the other student’s teams. Tutoring, lectures and an introductory exercise are offered alongside the project. All code is published on GitHub under an open source license. Christoph says:
When you leave here, you should have an idea of how to develop software in a team. It’s likely that you’ll work with others on some outdated legacy system in your later work life. As long as people have the ability to reflect on how their process, they are more likely to succeed in whatever they want to do.
Arian adds, “If you don’t practice good communication and you work in a setting with multiple teams, frustration is inevitable. The first time your code is thrown away because someone else has already completed your ticket is an important learning experience.”
Focusing on communication and self-organization shapes how students start coding: commit often, write clear commit messages, and learn from your mistakes. But first, students learn the basic tools and processes needed in an introductory exercise. However, managing these exercises for many students—and checking them manually—can get tedious.
Professor CI introduces students to technical tools using GitHub’s continuous integration services.
Participants work on their own repositories in Github and receive feedback and new challenges from the CI server when they push their code.
Arian is quick to note that using CI to help students fix their problems isn’t completely novel. The innovation, he says, is in how they use Professor CI with GitHub.
What is novel is using GitHub issues to motivate people and basically get them into the habit of tackling issues, writing tests and fixing bugs. If an Issue is done, you’re automatically sent another one that progresses the exercise—this is the new part. Prof. CI simulates a customer requesting new features, changes and bugfixes.
Summary of time from acceptance to completion of student tasks via Professor CI. For more details on the design and implementation, see the corresponding paper.
With Professor CI, students can work on their local machines, using their local development tools, and get the benefit of quick feedback from instructors. In turn, instructors have insight into students’ processes and code.
Christoph adds, “Automation is great for standardized exercises, but in the actual development project that follows, we rely heavily on human interaction.”
Building software in teams requires talking to real humans, so the next step in the course is gathering clear and concrete requirements from a stakeholder. As anyone who builds software knows, that’s easier said than done.
Instead of giving students clear requirements for their final project, Treffer and Matthies assign a co-worker the role of the customer, whose primary job is to—well—be a customer.
He throws ridiculous requirements at the students, and changes his mind constantly. Then the students have to get out of the customer what to build. They don’t get requirements. And the development process and all of its artifacts, they have to manage on their own.
This approach ensures that budding engineers get the close-to-real-world experience that the HPI hopes to instill. They develop real skills in listening, negotiating, and communicating that will help them code solid products and reduce wasted effort, wherever their degree takes them.
Treffer notes that students often think that development is chugging along better than it is, because they don’t yet have the experience required to identify problems as they arise. Milestones serve as natural points of reflection at which the group can work together to make processes better. They also closely monitor students, both with tutors and using GitHub tools to make sure they don’t deviate too much from development best practices.
Treffer and Matthies use a variety of exercises that help students find out what worked, what didn’t, and how to make next time better. The Sailboat is an exercise that students use to reflect on the development process.
In this exercise, the sun is what went right and the wind is what pushed the team in the right direction. The anchor represents what slowed the team down, and the rocks, of course, are potential future problems. Marking each feature of the boat scene allows the group to candidly diagnose how they work together.
Reflection exercises allow the students to get closer to one another and their professors to more intimately understand their students. Being able to collectively analyze and discuss what went right and what went wrong allows for some resolution to what might have been a rough sail. It also helps students learn how to collectively develop a process that will, ultimately, create better software and more efficient development time with minimal waste.
Basically, the most important aspect of our lecture is that students learn to apply what they’re doing to identifying problems with their development process and learn how to improve the process. It’s about figuring out which process works best for your team and context.