TH Köln

Master Digital Sciences

Dokumente zur Akkreditierung des Studiengangs

Modul »Coding Excellence« (CEX)

Informationen zur Organisation des Moduls

Modulverantwortung
Prof. Dr. Stefan Bente (Fakultät F10)
Lehrende
Prof. Dr. Stefan Bente (Fakultät F10), Prof. Dr. Matthias Böhmer (Fakultät F10), Prof. Dr. Christian Kohls (Fakultät F10)
Sprache
Englisch
Angeboten im
Wintersemester (falls Lehrkapazität vorhanden) (Dauer 1 Semester)
Ort
Campus Gummersbach, oder remote
Anzahl Teilnehmer*innen
minimal 4, maximal 20
Vorbedingung
keine
Empfehlung
Practical hands-on experience in coding, ideally from a longer research activity or from a business context
ECTS
6
Aufwand
Gesamtaufwand 180h
Kontaktzeit
24h (12h Seminar / 12h Projektbetreuung)
Selbstlernzeit
156h (davon 90h eigenständige Projektarbeit)
Prüfung
Semesterbegleitendes Projekt in Verbindung mit Präsentation und Fachgespräch
Vermittelte Kompetenzen
Analyze Domains, Model Systems, Implement Concepts
Beziehung zu globalen Studiengangskriterien
Digitalisierung, Transfer

Beitrag zu Handlungsfeldern

Nachfolgend ist die Zuordnung des Moduls zu den Handlungsfeldern des Studiengangs aufgeführt, und zwar als anteiliger Beitrag (als ECTS und inhaltlich). Dies gibt auch Auskunft über die Verwendbarkeit des Moduls in anderen Studiengängen und über die Beziehung zu anderen Modulen im selben Studiengang.

Handlungsfeld ECTS (anteilig) Modulbeitrag zum Handlungsfeld
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.

(WHAT?)

  • 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,

(HOW?)

  • … 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),

(WHY?)

  • … 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.

Inhaltliche Beschreibung des Moduls

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.

Lehr- und Lernformen

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

Zur Verfügung gestelltes Lehrmaterial

  • Current literature
  • Additional material depending on the topic at hand

Weiterführende Literatur

  • [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.