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.
Modulinhalt
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
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.