While the second semester of our Master in Software and Data Engineering (MSDE) is in full swing, we are reviewing and improving our first-semester courses. Our MSDE was born in Fall 2017, so we are excited about this first opportunity to reflect on our program! What worked well? What could be improved? Where are we headed? Let’s hear that directly from the instructors of our new courses:

Over the next few days, we will update this post with a brief interview about the following courses: Data Design & Modeling (Marco Brambilla) and Engineering of Domain-Specific Languages (Andrea Mocci).

Design 101

3 ECTS, Instructor: Michele Lanza

Michele, what makes your course unique?

D101 is a meta-course, it teaches students a set of universal design principles which are only loosely coupled to core computer science topics, but in reality due to their cross-cutting nature, then really manifest themselves in many different contexts. And indeed, the principles are then applied in the context of presentation design, data design, table design, or in general: information design. The course has a heavy focus on “lateral” thinking.

What did the students like about your course?

I’ve been teaching D101 a number of times now, also in other universities as an intensive seminar. The students always liked the fact that D101 allows them to connect dots which otherwise would remain alone. It’s really a holistic experience. For example, I also teach them things about the human perception system. On top of that everything is taught Lanza-style, if I may say so, which means fast and furious. In general, for anyone who ever went through the D101 experience, I keep getting feedback that in some weird way this is the course that marked them the most and had the most long-term benefits.

What will you improve?

For the next iteration we decided to extend D101 to 6 ECTS and to combine it with what was “Introduction to Software & Data Engineering” (ISDE). In the first iteration of our Master program we had these two courses in sequence, which had the negative effect of compressing D101 too much. Having now both things in one big 6 ECTS course actually gives me much more freedom in terms of how to distribute the course contents, and also makes the mini-project of ISDE much more contextual. Overall, I think this is a smart move and the Master program will benefit from that.

Software Design & Modeling

6 ECTS, Instructor: Gabriele Bavota

Gabriele, what makes your course unique?

Let me start by briefly summarizing what Software Design & Modeling (SDM) is about. The focus of SDM is on object-oriented design. The students learn how to assess (both manually and automatically) the design quality of object-oriented systems, how to identify and refactoring code antipatterns, and they get a deep understanding of design patterns.

These topics are particularly valuable in the context of large and complex software systems, and here is where SDM becomes unique. The course takes a hands-on, learning-by-doing approach with assignments performed on open source systems. For example, students were required to run a “design critique” of well-known open source systems having at least 50,000 lines of code. The goal was to identify design flaws by using code quality assessment tools and then design possible refactoring solutions to address them.

The ability to deal with large and complex systems is a basic skill in the era of large scale software and we want to make sure our students get exposed to “real code” sooner than later.

What did the students like about your course?

The student evaluations were quite positive, especially for what concerns the topics of the course, the idea of studying them in the context of real open source systems, and the teaching style:

I like that the course teaches tools and techniques to analyze and understand big projects.

The design pattern part is very interesting.

Very efficient teaching. Good communication. Very well done presentations.

What will you improve?

Interesting question since I will not teach this course next year. Don’t get me wrong, I loved teaching SDM and I’m kind of sad to let it go. However, our faculty is growing, and we continuously optimize our assignments of professors to courses. Next year, which will be the first time we teach the 3rd semester courses in our SDM, I will teach a course that is very close to my research: Software Analytics (stay tuned for more information about that in a future post)! Unfortunately this means that I won’t be able to continue teaching SDM.

Of course SDM will continue, and it will be improved! We have a fantastic instructor lined up to teach SDM next year: Carlo Alberto Furia, who is about to join our faculty. He has an extensive background in the area. I’m really excited to see how he will grow the course! Our students already provided helpful feedback on how to further improve SDM, and Carlo will thoroughly study that feedback. Most notably, the students asked for clearer guidance on what is exactly expected as output of the assignments. Honestly, I can understand their point of view, and this was kind of a planned risk when I decided to perform the assignments on open source projects. Being the first time I tried this, I did not have a crystal clear idea of where the bar was for our students when dealing with large and complex systems. So, I basically asked them to surprise me without giving strict output requirements…and I have to say that they did a great job!

Programming Styles

3 ECTS, Instructor: Matthias Hauswirth

Matthias, what makes your course unique?

I think Programming Styles is the most fascinating course I have created and taught so far. Why? Maybe because the course is a bit strange: it is unexpected and puzzling at first.

Programming Styles is a very practical course, but at the same time it’s conceptually deep. We look at programming as art. Like budding artists—be it painters, writers, or musicians—the students in Programming Styles practice producing works (programs) in multiple artistic styles. Note that in this course, “style” does not mean “fashion”. The styles students practice in this course are not superficial at all. They represent deep theoretical concepts such as higher-order functions, continuations, and monads. And of course turtles; all the way down. The intimate familiarity with those concepts is a central aspect that distinguishes normal developers from the 10x software engineers our program targets.

What did the students like about your course?

Creating this course was a bit of a gamble. I wasn’t sure how the students would react. Luckily, the student evaluations provide some indication that the gamble paid off:

Can I just write best course ever? It makes students do gymnastics for a chosen programming language: this course is the best way a student can boost their experience and knowledge about its preferred language. It also has peer reviews, so that you can learn not only about your language (and have other people’s opinions) but also other people’s languages too. It also introduces different programming paradigms (like functional and OOP) in a very basic level. It very effectively boosts a student knowledge in programming languages.

The students provided lots of constructive feedback that will help me to further evolve the course. I’m already looking forward to teaching the second, improved iteration of Programming Styles this fall!

What will you improve?

There are small improvements to be done throughout the course, but I see two main aspects I still need to work on:

I gave each student the freedom of using the programming language of their choice for implementing all the code in this course. I intend to do that again, next time. However, some students perceived the constraints imposed by the styles as negative: they did not like to “abuse” their chosen programming language in ways it was not designed. In the second iteration, I will more clearly set the expectations up-front, so that students are more informed when they pick their language.

A central point of the course is that students review the implementations of their peers. This exposes them to how the given style can be implemented in other languages. This reasoning across languages is a really important aspect of the course. Each week, I asked each student to present their own solution as well as reviews of the solutions of two of their peers. This was too much; it required too many presentations, and didn’t give enough time to discuss specific aspects, of specific languages, in detail. I plan to improve this by reducing the number of reviews, and by presenting additional reviews myself to set a concrete example.

How can we learn more about Programming Styles?

I use Informa, an online course platform I developed, to host all my courses, including the first instance of Programming Styles. Informa organizes the course contents into different themes and topics, it provides a list of skills I expect students to acquire in the course, and it provides all the material needed to study.

The course is based on a great textbook, “Exercises in Programming Style”, written by Crista Lopes. The book presents 33 different styles. In our course, we discuss a subset of those, in depth. I strongly recommend this book to any programmer out there. Read it. Work through it. And if you like that kind of stuff, join our MSDE program :)