@inproceedings{SoskaMottokWolff, author = {Soska, Alexander and Mottok, J{\"u}rgen and Wolff, Christian}, title = {Pattern oriented card game development: SOFTTY - A card game for academic learning of software testing}, series = {IEEE Global Engineering Education Conference (EDUCON), 25-28 April 2017, Athens, Greece}, booktitle = {IEEE Global Engineering Education Conference (EDUCON), 25-28 April 2017, Athens, Greece}, doi = {10.1109/EDUCON.2017.7942996}, abstract = {One of the biggest problems of educational games is the adequate integration of learning content into the game environment. Thereby the main challenge is to create a balance between gameplay and learning objectives and the correct transfer of learning principles into the game design. A useful approach is to identify game components and their specific learning constraints and the relationship between each other. By mapping learning elements to Game Design Pattern, we elaborate fundamentals for the concrete game design, focusing on card games. A shared description and an understanding of how the game design aligns with learning content facilitates the development of high quality educational games. A short illustration of our further developed implementation summarizes our experiences and shows an exemplary realization.}, language = {en} } @inproceedings{OsinskiLangerMottok, author = {Osinski, Lukas and Langer, Tobias and Mottok, J{\"u}rgen}, title = {A Survey of Fault Tolerance Approaches at Different Architecture Levels}, series = {30th International Conference on Architecture of Computing Systems, ARCS 2017, 3-6 April 2017, Vienna, Austria}, booktitle = {30th International Conference on Architecture of Computing Systems, ARCS 2017, 3-6 April 2017, Vienna, Austria}, pages = {1 -- 9}, abstract = {In the recent years the development trends for computing platforms moved to multicore systems. Associated with this trend, feature sizes decreased with each new hardware generation and consequently led to a rise of transient and permanent error frequency in memory and CPUs. In this context, researchers presented several approaches which exploit the inherent redundancy of multicore platforms to provide fault tolerance. We present a discussion of fault tolerance approaches based on redundancy at different levels of architecture regarding theirsphereofreplication,performanceaswellaserrordetection and recovery capability.}, language = {en} } @inproceedings{ReuterBeslmeislMottok, author = {Reuter, Rebecca and Beslmeisl, Magdalena and Mottok, J{\"u}rgen}, title = {Work in Progress: Teaching-Obstacles in Higher Software Engineering Education}, series = {8th IEEE Global Engineering Education Conference (EDUCON 2017), Athens, Greece}, booktitle = {8th IEEE Global Engineering Education Conference (EDUCON 2017), Athens, Greece}, doi = {10.1109/EDUCON.2017.7943067}, pages = {1631 -- 1635}, abstract = {Software Engineering is very abstract and complex by nature. Teaching Software Engineering in higher education is therefore still a big challenge. Although we implemented inductive teaching and learning methods in our courses for several years, we do not have a panacea. This paper aims to identify the remaining teaching obstacles in our Software Engineering courses with regard to the concrete teaching content. We present first ideas on how to overcome these teaching obstacles by the application of Augmented and/or Virtual Reality techniques with regard to the identified obstacles.}, language = {en} } @inproceedings{ReuterHauserGoldVeerkampetal., author = {Reuter, Rebecca and Hauser, Florian and Gold-Veerkamp, Carolin and Mottok, J{\"u}rgen and Abke, J{\"o}rg}, title = {Towards a Definition and Identification of Learning Obstacles in Higher Software Engineering Education}, series = {EDULEARN17 Proceedings, 9th International Conference on Education and New Learning Technologies, 3-5 July, 2017, Barcelona, Spain}, booktitle = {EDULEARN17 Proceedings, 9th International Conference on Education and New Learning Technologies, 3-5 July, 2017, Barcelona, Spain}, isbn = {978-84-697-3777-4}, issn = {2340-1117}, doi = {10.21125/edulearn.2017.0943}, pages = {10259 -- 10267}, subject = {Hochschuldidaktik}, language = {en} } @inproceedings{NivalaHauserJossbergeretal., author = {Nivala, Markus and Hauser, Florian and Jossberger, Helen and Reiß, Markus and Mottok, J{\"u}rgen and Gruber, Hans}, title = {Detecting errors in program flow diagrams: Comparing novices and advanced programmers}, series = {EARLI Biennial Conference 2017, 17th European Association for Research on Learning and Instruction, 29 August - 2 September, 2017 - University of Tampere, Finland}, booktitle = {EARLI Biennial Conference 2017, 17th European Association for Research on Learning and Instruction, 29 August - 2 September, 2017 - University of Tampere, Finland}, language = {en} } @inproceedings{ReuterKuhnMottok, author = {Reuter, Rebecca and Kuhn, Martina and Mottok, J{\"u}rgen}, title = {A Two-Sided Approach of Applying Software Engineering Perspectives in Higher Education}, series = {Teaching and Learning in a Digital World, ICL 2017, Proceedings of the 20th International Conference on Interactive Collaborative Learning - Volume 1}, booktitle = {Teaching and Learning in a Digital World, ICL 2017, Proceedings of the 20th International Conference on Interactive Collaborative Learning - Volume 1}, pages = {460 -- 467}, language = {en} } @inproceedings{KampmannMottok, author = {Kampmann, Matthias and Mottok, J{\"u}rgen}, title = {A 'laboratory' as an approach to foster writing skills at software engineering studies learning software engineering is easier when writing courses are directly dpplied to lecture's content and the problems and examples enrolled in}, series = {2018 IEEE Global Engineering Education Conference, EDUCON 2018, Santa Cruz de Teneriffe, Spanien}, booktitle = {2018 IEEE Global Engineering Education Conference, EDUCON 2018, Santa Cruz de Teneriffe, Spanien}, doi = {10.1109/EDUCON.2018.8363326}, pages = {900 -- 908}, abstract = {Writing, with no doubt, is besides reading a core competency which allows us to "exploit" knowledge in general. It also makes possible the exploration of software engineering's core issues. Especially within this context it is necessary to master the reading of complex texts as well as to be able to write in an appropriate academic expression. With regard to studies in software engineering this seems to be obvious, but in fact the opposite is the reality. Therefore measures to improve these skills seemed to be necessarily applied. At the Ostbayerische Technische Hochschule (OTH, University of Applied Sciences, Regensburg) a new format, the so called c*lab, was installed during the winter semester 2017. This was a course which followed the principle of "Writing Across the Curriculum" (WAC). Organized parallel to a lecture of learning how to program the language C, and addressing students of the first semester, the course was a complete voluntary offer in addition to the general standard courses and lectures of the faculty. Students who participated not only reflected on C and its principles, nor only on writing as a self purpose, but they also learned to express technical thoughts and ideas by the use of didactic methods. The idea to transfer also basic LTeX concepts to write a paper based on the IEEE bare_conf.tex-template were also planned. The course followed the idea of student's-centred learning. This paper presents the main structure, goals, and means of the c*lab, and the theory behind. It also embeds the course within the horizon of experiences of teaching writing skills at the Laboratory for Safe and Secure Systems (LaS 3 ) at the faculty of electronic and information engineering at the OTH Regensburg. First experiences have shown that participants increase writing skills and their idea of the importance of writing.}, language = {en} } @inproceedings{OsinskiMottok, author = {Osinski, Lukas and Mottok, J{\"u}rgen}, title = {Control Flow Errors: A Discussion of Different Injection Strategies}, series = {32nd International Conference on Architecture of Computing Systems, ARCS Workshop 2019, 20-21 May 2019, Copenhagen, Denmark}, booktitle = {32nd International Conference on Architecture of Computing Systems, ARCS Workshop 2019, 20-21 May 2019, Copenhagen, Denmark}, pages = {1 -- 7}, abstract = {Among the available dependability assessment techniques, fault injection (FI) is widely adopted and strongly recommended by safety standards for the validation that functional and technical safety mechanisms are implemented correctly and effectively. The main challenge in fault injection assessments is the increasing complexity of system-on-chips as well as the increasing size of memory, which leads to enormous efforts to test every possible fault introduced to the system. Therefore, a number of publicly available fault injection frameworks utilize fault space pruning techniques to reduce the overall fault space and consequently the overall experiment duration. Most of the fault space pruning techniques mainly discuss the reduction of the number of data errors which have to be injected into registers and memory locations. However, control flow errors represent a further domain of possible errors on the application level. Usually for the evaluation of effectiveness of fault tolerance mechanisms against data errors, a single fault assumption at microarchitectural level (e.g. bit-flips) is assumed. In most cases, this assumption is equivalently applied to the program counter to investigate possible control flow errors. Due to this approach, the error space is consciously or unconsciously reduced to the possible erroneous jump targets that can be reached by a specific set of bit-flips in the program counter at a specified time during the program execution. This approach is considered valid regarding the corresponding fault assumption, but leads to negative effects on the significance of the injection and the resulting effectiveness of the tested fault tolerance mechanism. In this paper, we discuss different strategies for the analysis and injection of control flow errors and the resulting differences by considering the single fault assumption at microarchitectural and application level.}, language = {en} } @inproceedings{LaloWeberSaileretal., author = {Lalo, Erjola and Weber, Raphael and Sailer, Andreas and Mottok, J{\"u}rgen and Siemers, Christian}, title = {On Solving Task Allocation and Schedule Generation for Time-Triggered LET Systems using Constraint Programming}, series = {32nd International Conference on Architecture of Computing Systems, ARCS Workshop 2019, 20-21 May 2019, Copenhagen, Denmark}, booktitle = {32nd International Conference on Architecture of Computing Systems, ARCS Workshop 2019, 20-21 May 2019, Copenhagen, Denmark}, pages = {1 -- 8}, abstract = {The amount of safety-critical embedded systems in automotive development is heavily growing. Ensuring their reliability not only increases the complexity of functions but also requires determinism at design and execution time, which is considerably challenging to fulfill and verify for multi-core processors. The Logical Execution Time (LET) is recently recognized in automotive industry as an approach for ensuring deterministic functional behavior. However, to decrease the manual design effort and time for deploying such complex systems to multi-core platforms and for ensuring their strict timing and safety requirements, automatic solutions are needed. This work presents a solution for allocating tasks to multi-core processors and generating a time-triggered schedule for embedded systems considering safety, timing, and LET semantics. The approach we propose solves both challenges by defining them as a Constraint Satisfaction Problem (CSP). To examine our CSP formulation, we use MiniZinc, which is a solver-independent constraint modeling language that can employ a variety of solvers. In a case study, we explore optimizations of an industrial system that are enabled by scheduling and task allocation design decisions. Further, the performance of the proposed solutions is evaluated based on large set of synthetically generated system models.}, language = {en} } @inproceedings{SchmidLangerOsinskietal., author = {Schmid, Michael and Langer, Tobias and Osinski, Lukas and Mottok, J{\"u}rgen}, title = {Parallel Active Object Pattern}, series = {31th International Conference on Architecture of Computing Systems, ARCS Workshop 2018,9-12 April 2018, Braunschweig, Germany}, booktitle = {31th International Conference on Architecture of Computing Systems, ARCS Workshop 2018,9-12 April 2018, Braunschweig, Germany}, isbn = {978-3-8007-4559-3}, abstract = {With parallel applications becoming more and more popular even in real-time systems, the demand for safe and easyto- use software libraries and frameworks for parallel and concurrent computations is growing immensely. These frameworks usually provide an implementation for different sets of software patterns. A very well known software pattern for concurrency is the Active Object pattern, that allows various threads to have synchronized access to an object in question. This paper presents the Parallel Active Object pattern, which extends the common Active Object pattern to support the use of objects, whose computations are profoundly enhanced by a parallel execution. Furthermore, a C++ software framework is introduced, which implements the Parallel Active Object pattern and thus provides the possibility of using task or data parallel patterns, for example Map, Reduce and Divide-and-Conquer, on the active object's calculations. The proposed framework is evaluated against two other popular libraries, namely OpenMP and Intel Threading Building Blocks. Through utilization of the C++11 standard and template classes a simple user interface is provided, which abstracts the distribution of workloads among the worker threads. By making use of the C++ Standard Template Library the framework can easily be ported to embedded systems and by extending the pattern through real-time capabilities, which ensure a timely and reliable execution of the method requests, the intention of providing the framework for time critical environments is also targeted in the future.}, language = {en} }