Code quality, metrics and mindset for students

Software testing seems abstract at first. In real systems, it takes shape: a pizza store in a Kubernetes cluster, end-to-end pipelines and observability make quality visible. The focus is on TDD, pair and mob programming, BDD and architecture as levers for testability. Conceptual thinking beats tool knowledge, classifies risks, metrics and coverage traps. Other topics include legacy code, meaningful logs, security, usability and performance, including GDPR pragmatics. AI serves as a tool, responsibility remains with the committer. Those who anchor quality early on carry it forward in teams and companies. This creates a practice that promotes robust software and ensures learning beyond the moment. This makes quality a joint effort, not a compulsory exercise.

Podcast Episode: Code quality, metrics and mindset for students

In this episode, I talk to Kai Renz about software testing at university. He shows why testing is difficult to teach at the beginning and how complex practical projects - a pizza store in a Kubernetes cluster - make sense. We talk about TDD, pair and mob programming, BDD and why conceptual understanding is more important than tool knowledge. Architecture as a lever for testability and dealing with legacy code, metrics and coverage traps. AI in your studies? Allowed, but responsible - anyone who commits code must understand it.

"It's quite difficult to teach students testing, especially at the very beginning, of course." - Kai Renz

Prof. Dr. Kai Renz is Professor of Software Engineering at the Department of Computer Science at Darmstadt University of Applied Sciences. He is primarily concerned with the subject area of "agile development". In his lectures and practical courses, Scrum, Kanban and Extreme Programming (XP) are taught and researched. He also focuses on the topic of professional testing. In June 2019, Prof. Renz was awarded the teaching prize (2nd prize) of Darmstadt University of Applied Sciences. Kai Renz has also been a certified Scrum Master since 2022.

Highlights der Episode

• Conceptual understanding of testing beats tool knowledge
• Architecture strongly influences testability and quality
• Metrics such as coverage are deceptive, meaningful testing delivers quality
• TDD, BDD and pair programming promote clean code and understanding
• AI is allowed, contributors understand and take responsibility for the code

Software testing at universities: Between theory, practice and artificial intelligence

Testing - a difficult start

Many students start their computer science studies with an enthusiasm for programming. The topic of software testing often remains on the sidelines. Professor Kai Renz from Darmstadt University of Applied Sciences describes exactly this problem: "If you have just learned to write a function, you don't immediately understand why you need a test. Initially, the tasks in the course are straightforward. What works seems to be easy to check. The need for tests therefore seems strange at first.

Students ask themselves: Why should I test code that I have just written myself and that even an AI like ChatGPT rates as correct? Only later do they realize how important quality assurance is - especially in complex projects. The transition from small exercises to real challenges is key. In the internship, for example, teams simulate a pizza store with real infrastructure. Suddenly, tests such as integration testing are necessary. Some then quickly understand the benefits, others only do what is necessary for the evaluation.

Test types and practice: finding the right balance

In class, students learn all the important test types: unit testing, integration testing, end-to-end testing and UI testing. The focus is not only on technology and tools, but also on the correct structure and conceptual understanding. Tools change quickly, the basic knowledge remains.

Professor Renz relies on methods such as Test-Driven Development (TDD). The key: first the team writes a test, then the actual function. This approach makes for exciting discussions, such as whether testing is even possible if the function does not yet exist. The method forces everyone to clearly formulate their requirements and objectives. Peer programming and coding sessions in the lecture hall help everyone to learn from each other.

Behavior-driven development (BDD) is also used. It combines technical testing with the user perspective. The elective subject "Professional Testing" guides students through various programming languages, tools and test types, including UI tests with Playwright. Many graduates report that they are able to apply their knowledge directly at work - often even better than some experienced colleagues.

Architecture and testability - the long road to quality

Good tests need a suitable architecture. If the business logic is too closely intertwined with the database or infrastructure, testing becomes complicated. In theory, this sounds sensible for experienced developers at the latest. For students, on the other hand, it is difficult to understand why they should separate classes cleanly - especially if it looks like overhead.

In practice, Professor Renz has seen that companies often have old software without sufficient testing. Refactoring without reliability is risky: no clean unit tests, no reliable architecture. Teams then build new parts correctly and transfer quality awareness to the passed parts bit by bit. But it takes time, patience and an open dialog - especially about quality.

Non-functional testing and interdisciplinarity

Performance, usability and security are just as important for quality as functionality. Darmstadt University of Applied Sciences has its own courses on IT security and human-computer interaction. There are plans to interlink the courses more closely, but this is a challenge in terms of organization. Awareness of performance testing, usability and security is being raised, but it will only be deepened in everyday working life.

Artificial intelligence: curse, blessing and learning opportunity

AI tools such as ChatGPT have long been part of everyday life for many students. Some use them for homework, others develop their own initiative. Exams without internet access set clear limits. It is crucial that students themselves know what their code is doing. Professor Renz takes a relaxed view as long as the responsibility for the result remains.

Awareness is growing: those who simply use AI without understanding it themselves will not succeed in their careers. The valuable skills lie in communication, understanding requirements and controlling the results.

Software testing as a future skill

A university education in software testing is demanding, but essential. Students learn technology, methods and the right mindset for quality. The combination of theory and practice is often challenging and yet makes all the difference. A breath of fresh air from research, openness to new ideas and continuous questioning - all this brings quality to the software and the team.

A well-conveyed understanding of testing ensures that students come to companies not only as users of technology, but also as critical designers and quality-conscious people. This is exactly what we need for good, secure software in the future.