dr. ir. Axel Faes - Research Diary

Learning to Teach While Learning to Lead

2025-10-06T00:00:00+00:00

What if work is too rough

I’m writing this at the end of a particularly intense period, two papers just submitted, multiple grant applications in various stages, and the final stretch of my BKO (Basic Teaching Qualification) at UHasselt. The pressure of postdoc life, securing funding, maintaining research output, developing as an educator, is very real.

But reflection has a way of clarifying what matters.

Teaching as Translation

When I started teaching in June 2024 with the Bioinformatics course, I assumed my computational neuroscience expertise would naturally translate to the classroom. I was wrong. Teaching biomedical students required learning an entirely new skill: translating technical concepts across disciplinary boundaries.

The breakthrough came when I stopped thinking about teaching as knowledge transfer and started thinking about it as context building. Biomedical students don’t need to become computer scientists, they need to understand how computational tools can answer their questions. This shift transformed how I designed lectures, practicals, and especially the coaching sessions that students later praised in evaluations.

The Reality of Interdisciplinary Work

My teaching spans multiple worlds:

Advanced Topics in Data Science (Master): teaching federated learning to computer science students
Bioinformatics (Bachelor): coordinating computational instruction for biomedical scientists
Data Science in Healthcare: explaining algorithms to healthcare professionals
Brain-Computer Interfacing (KU Leuven): guest lectures connecting theory to clinical applications

Each context demands different pedagogical approaches. What works for CS masters doesn’t work for nursing students. The common thread? Start from their world, not mine.

Learning from Failure: The AI Dilemma

Not everything goes smoothly. During Bioinformatics project evaluations, we told a student group their report contained “ChatGPT hallucinations.” Their response, documented in course evaluations, was devastating. They felt accused of academic dishonesty when they’d only used AI for spell-checking, as UHasselt encourages.

This incident exposed my own uncertainty. Where exactly is the line between legitimate AI assistance and problematic use? How do we have constructive conversations about AI-generated content without making accusations?

I’m participating in the “Make Your Course AI-Proof” workshop on October 23, 2025, because I need these answers. The technology is evolving faster than pedagogical frameworks, and honestly, it stresses me out. But avoidance isn’t an option, our students are already using these tools, and they need guidance, not prohibition.

Mentorship: The Invisible Infrastructure

I supervise six master’s theses this year, co-supervise a doctoral student, and coordinate research across multiple institutions through the Flanders AI Research Program (Use Case Real World Evidence). The time investment is substantial, and balancing it with my own research and grant writing is challenging.

But when I see students present work that becomes publications, or better yet, when they develop the confidence to tackle complex problems independently, the investment feels worthwhile.

What makes this possible? Prof. Liesbet Peeters.

She’s been my mentor since day one at UHasselt, and her approach to mentorship has fundamentally shaped how I think about academic leadership. She doesn’t just offer advice, she creates conditions for growth. She encourages experimentation, normalizes failure as learning, and consistently demonstrates that supporting others’ development is not separate from research excellence but integral to it.

I try to pay this forward with the students I supervise. Not always successfully, I’m still learning to balance support with appropriate challenge, and to recognize when I’m overcommitting, but with intention.

What I’m Learning About Teaching

Through the BKO process, I’ve identified patterns in my development:

From individual to collective: I used to think good teaching was about individual preparation. Now I understand it’s about team coherence. The positive evaluations in Bioinformatics came not from my lectures alone but from how our interdisciplinary team created a coherent learning experience.

From implicit to explicit: So many teaching problems stem from assumptions left unstated. Evaluation criteria, acceptable AI use, expected time investment, if it’s not explicit, students will fill gaps with their own assumptions, often incorrectly.

From reactive to reflective: The BKO structure forces systematic reflection. Instead of only reacting when problems arise, I’m building habits of regular evaluation and adjustment.

From expertise to empathy: My technical knowledge matters less than my ability to understand where students are and what they need to get where they’re going. This sounds obvious but required unlearning ingrained academic habits.

The Bigger Picture: Why This Matters

AI in healthcare, federated learning for sensitive data, brain-computer interfaces for motor restoration, my research sits at intersections where technical capability meets human impact. Teaching the next generation isn’t separate from this work; it’s central to it.

Students graduating today will face challenges we can’t fully anticipate. They need more than algorithms, they need judgment about when to use them, ethical frameworks for deployment, and the ability to communicate technical work to non-technical stakeholders.

This is what drives my teaching: preparing students not just to apply existing techniques but to navigate complexity, communicate across boundaries, and think critically about the implications of their work.

Acknowledgments and Looking Forward

To my students, past, present, and future, thank you for your patience with my learning process. Your feedback, even when difficult to hear, has been essential.

To Prof. Liesbet Peeters: your mentorship has been transformative. You’ve shown me what academic leadership can look like when it prioritizes growth over gatekeeping.

To fellow early-career researchers navigating similar pressures: you’re not alone. The funding stress, the publication pressure, the impostor syndrome, it’s part of the terrain. Find your people. Ask for help. Celebrate small wins.

The postdoc phase is demanding, but it’s also formative. I’m learning to teach, to lead research teams, to mentor, and to balance competing demands. Not perfectly, far from it, but with intention and support.

And that, perhaps, is enough.

This post is part of my reflection on completing the BKO (Basic Teaching Qualification) at UHasselt. If you’re interested in federated learning, brain-computer interfaces, or the intersection of AI and healthcare, feel free to connect.

Cardinal - a Scripting Language for Education and Research

2025-08-15T00:00:00+00:00

Introducing Cardinal: A Lightweight Scripting Language for Education and Research

If you’ve ever wanted to peek under the hood of a programming language, to really understand how virtual machines work, how concurrency models are implemented, or how compilers translate high-level code into bytecode, you need a codebase that’s both powerful enough to be interesting and clean enough to be comprehensible. That’s where Cardinal comes in.

Cardinal is a lightweight concurrent scripting language that brings together the elegance of Wren with the clarity needed for education and research. In this post, I’ll introduce you to what makes Cardinal special, explore its syntax and design philosophy, and explain why it might be the perfect tool for your next language implementation course, research project, or embedded scripting needs.

What is Cardinal?

Cardinal is a C++ rewrite of the Wren programming language, designed with a specific focus: making language implementation accessible for students, researchers, and anyone curious about how programming languages work under the hood. While it preserves Wren’s core goals of minimalism, speed, and expressive object-oriented design, Cardinal goes further by prioritizing code readability and educational value.

The language draws inspiration from several influential languages:

Wren provides the core syntax and design philosophy
Smalltalk influences the pure object-oriented approach
Lua inspires the embeddability and lightweight runtime
Erlang contributes to the concurrency model through lightweight fibers

What sets Cardinal apart is its implementation philosophy. The entire VM and runtime are compact, heavily commented, and written in modern C++20. There are no external dependencies, making it trivial to build and study. Whether you’re teaching a programming languages course, conducting research on type systems, or just want to embed a scripting language in your application, Cardinal provides a clean foundation to build upon.

A Taste of Cardinal Syntax

Cardinal’s syntax will feel immediately familiar if you’ve worked with languages like JavaScript, Python, or Ruby. Here’s the classic first program:

System.print("Hello, world!")

Classes are first-class citizens in Cardinal, forming the core abstraction of the language:

class Bird {
  construct new(species) {
    _species = species
  }
  
  species { _species }
  
  sing() {
    System.print("The %(_species) sings!")
  }
}

var cardinal = Bird.new("cardinal")
cardinal.sing()  // The cardinal sings!

Notice the string interpolation with %(_species), a clean way to embed expressions directly in strings. Cardinal uses a constructor pattern with construct new() and private fields prefixed with underscores. Getters can be defined simply by writing a method without parameters.

One of Cardinal’s most interesting features is its built-in support for lightweight concurrency through fibers. Fibers enable coroutine-style concurrency without the complexity of threads:

class Counter {
  static countTo(n) {
    return Fiber.new {
      for (i in 1..n) {
        Fiber.yield(i)
      }
    }
  }
}

var counter = Counter.countTo(5)
while (!counter.isDone) {
  System.print(counter.call())
}
// Prints: 1, 2, 3, 4, 5

This example demonstrates how fibers can yield values, allowing you to write generator-style code that’s both elegant and efficient. The fiber suspends execution at each yield, returning control to the caller, and resumes where it left off on the next call().

The Connection to Wren

Cardinal is more than just inspired by Wren, it’s a deliberate C++ reimplementation that maintains compatibility with Wren’s syntax and semantics while improving on the educational and research aspects. The original Wren is written in C and focuses on being a minimal, fast embeddable scripting language.

Cardinal takes Wren’s solid foundation and asks: “What if we rebuilt this with modern C++, extensive comments, and education as a first-class goal?” The result is a codebase that:

Uses modern C++20 features for clearer code structure
Includes extensive inline documentation explaining design decisions
Separates concerns in a way that maps naturally to programming language curricula
Maintains the single-pass compilation to bytecode that makes Wren fast
Preserves Wren’s compact object representation

For researchers and educators, this means you can use Cardinal to teach the same concepts you’d teach with Wren, but with a codebase that’s more approachable for study and modification. Students can trace through the code and understand not just what it does, but why particular design decisions were made.

Why Cardinal Excels in Education and Research

Cardinal was designed from the ground up with academic use cases in mind. Here’s why it’s particularly well-suited for educational and research contexts:

For Teaching Programming Languages

The VM and runtime are deliberately kept small and readable. Each component is heavily commented, making it suitable for:

Courses on programming language implementation
Virtual machine design and optimization
Compiler construction
Concurrency models and implementation

The clean separation of concerns means you can focus on one aspect at a time, study the garbage collector without getting lost in parser details, or examine the bytecode compiler without worrying about the runtime.

For Research Projects

Cardinal provides an excellent platform for:

Master’s thesis projects on type systems, effect handlers, memory models, GC strategies, and concurrency paradigms
Rapid prototyping of new language features thanks to the higher-level C++ implementation
Experimental implementations of novel ideas without the overhead of building infrastructure from scratch

The small footprint enables fast iteration, you can modify the language, rebuild, and test your changes in seconds rather than minutes. And because it compiles to bytecode, you can experiment with runtime optimizations and see their effects immediately.

For Labs and Capstone Projects

Cardinal is sized perfectly for semester-long projects:

Extend the language with new features (pattern matching, optional types, etc.)
Implement different garbage collection strategies
Add new concurrency primitives beyond fibers
Optimize specific aspects of the VM or compiler

The codebase is large enough to be interesting but small enough that students can grasp the whole system by the end of a semester.

Practical Features

Beyond its educational value, Cardinal is a fully functional language suitable for real-world embedding:

No external dependencies: The entire language requires only a C++20 compiler
Embeddable by design: Clean C++ API for integrating into your applications
Header-only option: A single-header amalgamation is available for rapid prototyping (perfect for quick experiments, though it trades some performance for convenience)
Cross-platform: Builds on Linux, macOS, and Windows with standard toolchains
Minimal standard library: Small footprint keeps things simple

Getting Started

Building Cardinal is straightforward. The project includes a helpful Python build script that handles everything:

# Build Cardinal
python3 utils/build.py --build

# Run tests
python3 utils/build.py --test

# Run benchmarks
python3 utils/build.py --benchmark

You can also use CMake directly if you prefer. The project is well-documented with clear build instructions for multiple platforms and toolchains.

What’s Next?

In future posts, I’ll dive deeper into Cardinal’s implementation:

How the single-pass compiler generates bytecode
The design and implementation of the fiber-based concurrency system
Exploring the garbage collection strategy
The advanced feature: algebraic effect handlers with multishot continuations
Extending Cardinal with custom foreign classes and methods

Cardinal represents a unique intersection: a language that’s simple enough to understand fully, yet sophisticated enough to explore real implementation challenges. Whether you’re teaching the next generation of language implementers, researching novel language features, or just curious about how scripting languages work, Cardinal provides a clean, approachable foundation.

If you’re interested in programming language implementation, I encourage you to check out Cardinal on GitHub. The codebase is waiting to be explored, modified, and extended, and that’s exactly what it was designed for.

In the next post, we’ll take a deeper look at Cardinal’s bytecode compiler and see how it transforms source code into executable instructions in a single pass.

Finding Rhythm: Building a Sustainable Voice in Academia

2025-06-15T00:00:00+00:00

Finding Rhythm in Academic Communication: One Post at a Time

A few weeks ago, I made a personal commitment: to bring a bit more structure and intention to how I share my academic journey online.

Between research deadlines, teaching, grant writing, and supervision, social media can easily feel like noise. But over the past months, I’ve realized that platforms like LinkedIn can also be powerful spaces for reflection, connection, and visibility, not just for “self-promotion,” but for showing what research actually looks like from the inside.

So, I decided to adopt a simple rhythm: one post per week, four themes that repeat every month.

Week 1: Reflection and honesty

Academia can be intense. My first post in this new rhythm was a candid reflection on exhaustion, perfectionism, and the importance of mentorship. It wasn’t meant to be polished or strategic, just honest.

The response reminded me how many people quietly feel the same way. Writing about the mental load of research opened a space for conversation and empathy. That’s something I want to keep nurturing.

Week 2: Behind the research

Next week I’ll share my excitement for the Federated Learning Technologies and Applications (FLTA 2025) conference, where I’ll present work on extending Block-Term Tensor Regression to federated settings for privacy-preserving biomedical analysis.

These posts are a chance to bring people closer to the science itself, not just the results, but the questions, collaborations, and messy problem-solving that happen along the way.

Week 3: Thought leadership and curiosity

Some weeks, I’ll focus on unpacking a concept that matters to my field. For example:

Federated learning isn’t just about moving models instead of data, it’s about trust.

Posts like that give me space to think out loud, explain complex ideas in plain language, and invite others to share their perspectives. They’re less about outreach and more about conversation.

Week 4: Mentorship and community

Science doesn’t happen in isolation. Many of my most meaningful moments come from teaching and mentoring, helping students turn complexity into clarity.

Dedicating one post a month to that theme keeps me grounded. It’s a reminder that our impact often lies in how we support others, not just in what we publish.

Why this rhythm matters

Posting once a week isn’t about chasing engagement metrics. It’s about building a sustainable, authentic habit of communication, one that reflects the real rhythm of academic life: thinking, creating, sharing, and learning.

By alternating between personal reflection, research updates, conceptual deep dives, and community focus, I can show the whole picture of being a researcher, the science, the struggle, and the people behind it.

If you’re also trying to find your balance between research and communication, maybe this kind of rhythm could help. One post a week is enough to stay connected without burning out.

📢 I’ll keep experimenting with this format over the coming months, starting with my FLTA 2025 post next week. If you’re curious about federated learning, healthcare AI, or the realities of academic life, you can follow along on LinkedIn.