From March to June 2018 I have the great privilage to be the visiting professor for the course Software Engineering at the Ostfalia university in Wolfenbüttel, Germany, in representation of Prof. Dr. Bernd Müller. Most of the students study computer science and are in their 3rd term. This article explains what topics I teach and why.

Overall-Goal

After agreeing to the job of representing Bernd, I thought about the overall-goal of the lectures. What should a student take away from my talks? The short duration of only one semester and the relatively young students made me think of delivering an overview of the broad field of Software Engineering, not an in-depth explanation of one or two topics. I set the goal to this:

“During this course, I want you to learn everything a junior developer should bring with him when joining my team.”

That means that a lot of topics will only be mentioned on the side and very few in detail. All those topics are meant to be an appetizer for more studies. Also, I added a lot of best practices and practical expertise that I gained during my years in the industry.

Elements of Software Engineering

As you can see in the picture of this article, I comprehend Software Engineering as way more than just coding. There are a lot facets of our craftsmanship that should at least be mentioned to young students, so that they see the bigger picture. Also, teaching specific detailed technology is most likely not the best approach, because it’s outdated when the students hit “real” projects for the first time. These two thoughts drove me in creating the following curriculum.

Software Engineering from 10.000ft

The first part of the lectures is an overview of the broad field of Software Engineering. Beginning from the opinionated view that the creation of software is more a biological than a straight-forward “build it” process, the already mentioned elements of Software Engineering were introduced. I focused specifically on the important role of the community because in my opinion, a healthy community is what brings the most progress on the long term. Hence, the so-called “soft” skills are also mentioned as a core competence for every modern software craftsman.

Git

Although many students already are familiar with Github and Git itself, there’s not much practical expertise because of lack of opportunity. Hence, problems resulting from more complex projects are not known. Also, branching models like GitFlow are shown as well as the usual tools like GitKraken and GitLab.

Maven

Of course one representative of the build tools should appear in my course. Nobody is building large enterprise projects manually or with Ant (I hope so). Thinking about the two commonly known and used tools Maven and Gradle, I chose Maven because it has the nice convention-over-configuration best practice that everybody should know. Also, it’s still very widespread in projects. While explaining the contents of a pom file, I added the concept of semantic versioning because it has been most useful for me.

Junit

Of course, this central Java framework has to have an appearance, together with Test-Driven-Development and a demo using the Game of Life. To build a mental bridge to the already-mentioned topics of Git and Maven, I built a small demo application that is using Maven, published on Github and run by Travis CI. That way, the students see a simple continuous integration pipeline. Also, it’s cool to show some action: “If I make this test run red and commit and push, it will appear here, the build will be triggered, tests will fail, the build badge will change.”

Refactoring

After having shown these most essential parts of building software, it’s time for some best practice and seeing code. From the classic book “Refactoring”, I show a lot of examples for code smells, simple refactorings and explain what a real refactoring feels like. The difference between the shown very simple actions to real, multi-week long refactorings is huge and I tell stories about what can go wrong, how it feels and how to deal with these issues.

Awesome Java Code

Up until this part, I created all the slides, examples and code snippets (more or less) myself. However, because of the many years I provide inhouse and external workshops and talks, I have a nice set of existing workshops I can use. One of those is “Writing awesome Java Code” which includes everything from simple best practices, explanations of how lambdas can be used up to nice API design. I add some basics of Java 8 because not all students are familiar with the new APIs.

JavaFX

Another existing workshop is a couple of years old, but still good to show concepts like Composite Pattern, Separation of Concerns and Inversion of Control: my seasoned JavaFX-Workshop. At least one frontend technology should be known and JavaFX as the alternative for web-applications is a solid choice.

Spring Framework

When writing modern Java applications, either JEE or Spring is used as the main framework. Because I don’t know JEE, my choice was to present the most important aspects of the Spring framework like Dependency Injection, Profiling, Java Configuration and JPA.

Domain Driven Design

DDD is a relatively old concept that gained traction in the recent years. In my opinion, it passed the barrier from “just a hype” to “ripe for production” successfully and should be explained to students because the concepts of a common language between every stakeholder plays well with current agile approaches. Because I’m not that experienced with the topic, I let Oliver Milke talk.

Agile Methods

As mentioned, DDD plays well with agile methods, which I also present. Although I am a huge fan of the agile mindset, I explain most recent approaches like Scrum and Kanban and put them into perspective with different types of customers. Agile is not always the way to go, but is a tool that should be in the belt of every modern developer.

Management 3.0

The last lectures will be less code-centric and more process-oriented. A very “soft” topic is the (hype-) term “Management 3.0” that originates in a book by Jurgen Appelo. A lot of thoughts I mentioned during the semester will be merged together in a mindset that favors agility, self-managed teams and (my favorite word) communication. I hope to provide a glimpse into the complex world of IT-project-management and create some craftsmanship-thinking in my students.

Cloud & Digitalization

I had my first real experiences with cloud technology just recently and it made me understand how important this technology(-collection) is. After explaining fundamentals like the difference between IaaS and PaaS, there will be examples deployed on Pivotal Cloud Foundry. This will not only show how utterly important basic topics like build tools and testing are, but also show the game-changing characteristic of cloud technologies. During the course of a couple of years, it has become a matter of minutes and exactly zero money to put an application to production. This is an important aspect of the hype of Digitalization, which I will talk about briefly.

Ethics in Software Engineering

The final session of my lectures will be about a topic that has been the core of IT ever since, but is chronically underrepresented: The ethics of software engineering. I talk about different aspects of current IT projects like the gathering of data and licensing and their implications. The fundamental message of this is that every developer of a system is ultimately responsible for what this system is used for.

Open-Source Material

All the material mentioned above is publicly available on Github.