TH Köln

Master Digital Sciences

Documents for Study Program Accreditation

Module »Coding Excellence« (CEX)

Organizational Details

Responsible for the module
Prof. Dr. Stefan Bente (Faculty F10)
Lecturer(s)
Prof. Dr. Stefan Bente (Faculty F10), Prof. Dr. Matthias Böhmer (Faculty F10), Prof. Dr. Christian Kohls (Faculty F10)
Language
English
Offered in
Winter Semester (if sufficient lecturer capacity available) (Duration 1 Semester)
Location
Campus Gummersbach, or remote
Number of participants
minimum 4, maximum 20
Precondition
none
Recommendation
Practical hands-on experience in coding, ideally from a longer research activity or from a business context
ECTS
6
Effort
Total effort 180h
Total contact time
24h (12h seminar / 12h project supervision)
Time for self-learning
156h (containing 90h self-organized project work)
Exam
Project (during semester) in conjunction with a presentation and an expert talk
Competences taught by the module
Analyze Domains, Model Systems, Implement Concepts
General criteria covered by the module
Digitization, Transfer

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.

Focus Area ECTS (prop.) Module Contribution to Focus Area
Architecting and Coding Software 6

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

Learning Outcome

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,
  • by
    • 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, nature),
  • so that I have a fact-based way of making up my mind in the VUCA world of professional software development,
    • 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.

Module Content

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] or [Coleman12].

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

Literature

  • [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.). Addison-Wesley Professional.
  • [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.