Mapping to Focus Areas
Below, you find the module's mapping to the study program's focus areas. This is done as a contribution to all relevant focus areas (in ECTS, and content-wise). This is also relevant for setting the module in relation to other modules, and tells to what extent the module might be part of other study programs.
||Module Contribution to Focus Area
|Architecting and Coding Software
In this module, the students will research specific topics from the field of software coding that are relevant for professional software development; these topics represent design choices for development teams when using current programming paradigms
After completing CEX, the following statement should be true for the particapating students.
- As an experienced software developer, I am able to …
- assess new trends in the software industry, and
- act as a multiplier within my own organization with regard to such topics,
- staying up-to-date with cutting edge trends in the software industry and the developer community,
and therefore being able to identify interesting trends and subjects,
- analyzing and researching sources that assess these trends (and by being able to
prioritize such sources according to their respective standing the software community)
- designing my own hands-on proof-of-concept projects, thus being able to prove or disprove some
hypothesis on my own or in a small team,
- performing a criteria-based assessment, based both on research and hands-on trial, and
- summing up my results in a compact and easy-to-understand way for my peers and superiors,
- so that I have a fact-based way of making up my mind in the VUCA world of professional software
- meaning that on the one hand, I am able to adopt new technologies, methods, and paradigms,
when & where they make sense for my work,
- and on the other hand I won’t follow blindly each and every new trend, just because it is new.
In this module, the students will form subteams of 2-4 persons, and research a specific topic from the field
of software coding. The lecturers will propose topics, but the students may also propose topics
themselves. The topics have to be related to aspects of “Coding Excellence” as e.g. expressed in [Martin08]
The research topics will be aspects of coding that are relevant to professional software development.
They represent - in some way or another - design choices that development teams face when using
current programming paradigms. Two examples for such topics should illustrate the concept:
- Will the use of modern JVM-based language like Kotlin - which follow the Don’t Repeat Yourself (DRY)
paradigm - make a development team more productive, compare to e.g. Java? What proof can be found
in support of a “yes” or “no” answer? Can the effect (or the lack of an effect) be shown in a
sample coding project?
- If you follow a state-of-the-art programming paradigm like Test-Driven Development (TDD), what granularity
of unit testing is best suited to optimally support a team workflow? What criteria have literature and
online sources to offer? How can this be tested in a hands-on trial project?
The idea of this module is to use a hybrid approach to tackle such topics.
“Hybrid” means that it combines scientific research methods with empirical hands-on work in small teams.
Both ways have their merits. Both are essential for an experienced coder. Due to the rapid innovation
pace in the field of software development, relying only on academic knowhow is not enough.
Many relevant aspects in modern coding just haven’t been researched (enough) yet. Or, they never really
will be, at least not before yet another new paradigm enters the stage, and renders them moot.
Studying these aspects only by hands-on work is similarly unsuitable. Therefore, the hybrid
approach is key to this module.
Forms of Teaching and Learning
The module is held by a team of lecturers, each of whom contributes up-to-date topics to the module,
depending on one’s availability and current research focus. The module is organized like this:
- Kickoff (together with students) to collect, refine, and decide the research topics,
- Formation of small teams (2-4 students), with a responsible lecturer
- Under guidance of a lecturer:
- literature research on the topic
- design of an empirical coding project, as a proof-of-concept or experiment
- coding the “deep-dive” example
- assessing and summarizing the findings
- Presentation workshop
Learning Material Provided by Lecturer
- Current literature
- Additional material depending on the topic at hand
- [Beck02] - Beck, K. (2002). Test Driven Development: By Example (01 ed.). Addison-Wesley Professional.
- [Coleman12] - Coleman, E. G. (2012). Coding Freedom: The Ethics and Aesthetics of Hacking.
Princeton University Press. http://ebookcentral.proquest.com/lib/koln/detail.action?docID=1042909
- [Fowler18] - Fowler, M. (2018). Refactoring: Improving the Design of Existing Code (2nd ed.).
- [Lilienthal15] - Lilienthal, C. (2015). Langlebige Software-Architekturen: Technische Schulden analysieren,
begrenzen und abbauen (1st ed.). dpunkt.verlag GmbH.
- [Martin08] - Martin, R. C. (2008). Clean Code: A Handbook of Agile Software Craftsmanship (1st ed.). Prentice Hall.