Artificial Intelligence (AI)-based emotion recognition using various kinds of data has attracted vast attention in recent years. Impressive results have been achieved, but only recently the influence of the training data with its potential biases and variations in annotation quality are discussed. Still, the majority of the research literature focuses on improving machine learning techniques and model performance using single data sets. Literature on the impact of training data remains scarce. Therefore, in this paper we investigate the influence of the training data on the accuracy of recognizing emotional states in facial expressions by a comparative evaluation, using multiple established facial image databases. Results reveal inconsistencies in the data annotations as well as ambiguities in the emotional states expressed. Thus, they allow to critically discuss data quality of the training data, contributing to a more in-depth understanding of previous emotion recognition approaches, and improving the design of more transparent AI solutions.

This is a preliminary case study examining the use of a hands-on IT security activity to raise awareness regarding IT security issues at undergraduate non-major students with little or basic knowledge in SQL and programming. In order to communicate IT security to this target group in an understandable and clear sense, the learning scenario focuses only on the specific threat caused by SQL injection. The evaluation of the scenario by questionnaires proved the potential of hands-on SQL injection exercises and simulating a hacker attack as a successful approach for IT-security education.

This paper presents a game prototype to be used in introductory programming education with JAVA and compares a visualization-based and play-based game design approach for an educational game. The presented approach in particular addresses female students, since they showed low self-confidence in programming class evaluations. Results provide insights into students' perception of programming and highlights the advantages of a play-based approach. In addition, the paper explores how the results are used to further improve the game prototype.

Cryptocurrencies, blockchain technology and smart contracts could fundamentally change the way how financial products and financial services are implemented and operated. While many frameworks for implementing such blockchain applications already exist, these are usually implemented using languages either considered “fancy” today, like e.g. Go, or are traditionally used for system software, such as C++. On the other hand, the core business applications e.g. in financial services are typically implemented using enterprise platforms such as Java Enterprise Edition (EE) and/or COBOL. Therefore, to improve the integration of blockchain technology in such applications, in this paper we argue in favor of a legacy-friendly distributed ledger solution by introducing QWICSchain, an implementation build on web services using established open-source enterprise technologies such as Java EE and PostgreSQL. It supports the parallel execution of transactions on the blockchain and in existing legacy applications, thus enabling the blockchain-based modernization of existing IT infrastructures.

Content Management Systems (CMS) are widely adopted commodity applications today. Well-established implementations exist since many years, both commercial and Open Source, e.g. WordPress or Drupal. In consequence, research on CMS has strongly declined since its peak more than a decade ago. However, in recent years new trends for building and running large-scale web applications emerged, such as Node.js, microservice architectures and containerization, while most established CMS still use a traditional monolithic architecture. This rises the question how these emerging new technologies will challenge those established CMS implementations. Therefore, in this paper a microservice architecture for an examplified e-business CMS is proposed, and a Proof-of-Concept implementation is described. The approach is evaluated with respect to its feasibility using a qualitative empirical study. Results indicate that the approach is well-suited for building more state-of-the-art CMS in the near future, which are likely to challenge the position of the traditional monolithic implementations.

Despite the common notion of mainframe-based transactional COBOL applications being an outdated technology, in many companies they continue to serve as the IT backbone. Therefore, in the era of big data and cloud services, these applications need to be transformed towards open, service-oriented architectures to preserve their value. This challenge has been tackled by different strategies so far, ranging from adding web service layers to existing mainframe applications to various products providing emulation on non-mainframe platforms. In contrast, in this paper this transformation is considered not as a mere COBOL re-hosting issue, but from the perspective of integrating COBOL in Java EE-based web applications. An open framework is demonstrated for executing existing transactional COBOL programs as part of Java EE application servers. It is build on established Open Source Software (OSS) components and executes on any Un*x-like operating system, in particular also on the mainframe itself.

Many mobile apps today support interactions between their users and/or the provider within the app. Therefore, these apps commonly call a web service backend system hosted by the app provider. For the implementation of such service backends, load tests are required to ensure their performance and scalability. However, existing tools like JMeter are not able to simulate “out of the box” a load distribution with the complex time evolution of heterogeneous, real and interacting users of a social app, which e.g. would be necessary to detect critical performance bottlenecks. Therefore, in this paper a probabilistic model for simulating interacting users of a social app is proposed and evaluated by implementing it in a prototype load testing tool and using it to test a backend of new real-world social app currently under development.

Task-based Programming Learning (TBPL) is an approach which is based on ideas of Task-based Language Learning in second language acquisition. It can use output-prompting and input-providing tasks. This paper describes the theoretical background and methodical aspects of the input-providing TBPL variant and its implementation in higher education courses. The approach was implemented and evaluated in five different programming courses from both students (N=165) and lecturers (N=4). It became clear that the TBPL-approach has several positive aspects and that it can serve as a valuable instrument for learning and teaching programming in higher education.

Virtual worlds and avatar-based interactive computer games are a hype among consumers and researchers for many years now. In recent years, such games on mobile devices also became increasingly important. However, most virtual worlds require the use of proprietary clients and authoring environments and lack portability, which limits their usefulness for targeting wider audiences like e.g. in consumer marketing or sales. Using mobile devices and client-side web technologies like i.e. JavaScript in combination with a more automatic generation of customer-specific virtual worlds could help to overcome these limitations. Here, model-driven software development (MDD) provides a promising approach for automating the creation of user interface (UI) components for games on mobile devices. Therefore, in this paper an approach is proposed for the model-driven generation of UI components for virtual worlds using JavaScript and the upcoming Famo.us framework. The feasibilty of the approach is evaluated by implementing a proof-of-concept scenario.

Object-oriented programming (OOP) is widely used in the software industry and university introductory courses today. Following the structure of most textbooks, such courses frequently are organised starting with the concepts of imperative and structured programming and only later introducing OOP. An alternative approach is to begin directly with OOP following the Outside-In teaching method as proposed by Meyer. Empirical results for the effects of Outside-In teaching on students and lecturers are sparse, however. We describe the conceptual design and empirical evaluation of two OOP introductory courses from different universities based on Outside-In teaching. The evaluation results are compared to those from a third course serving as the control group, which was taught OOP the "traditional" way. We evaluate the initial motivation and knowledge of the participants and the learning outcomes. In addition, we analyse results of the end term exams and qualitatively analyse the results of interviews with the lecturers and tutors. Regarding the learning outcomes, the results show no significant differences between the Outside-In and the "traditional" teaching method. In general, students found it harder to solve and implement algorithmic problems than to understand object oriented (OO) concepts. Students taught OOP by the Outside-In method, however, were less afraid that they would not pass the exam at the end of term and understood the OO paradigm more quickly. Therefore, the Outside-In method is no silver bullet for teaching OOP regarding the learning outcomes but has positive effects on motivation and interest.

The high relevance of IT skills for most job profiles today requires to teach computer science and software engineering topics to an increasing number of students from non-major computer science programs (i.e. business administration). Due to their different knowledge and motivation this is a special challenge and requires suitable didactical methods and concepts. Since the research literature on this issue is sparse, the present paper provides a first overview about these challenges and methods and presents results of a first analysis of selected methods in practice.

Graphical user interfaces (GUI) of modern web applications offer a look-and-feel comparable to desktop applications, mainly by using JavaScript or other Rich internet Applications (RIA) technologies. With W3C’s upcoming HTML5 standard, even more powerful concepts for browser-side GUI programming are introduced, e.g. the -tag. Model-driven development of web applications and RIA has been studied for many years. However, all existing approaches for model-driven web and RIA development focus on entire webpages. With the increasing complexity of modern web GUIs, the model-driven development of GUI components itself comes into focus. Therefore, in this paper a method is proposed for the model-driven development of interactive, JavaScript-based GUI components based on the -tag. Using a metamodel based on an UML 2.0 profile, the approach is usable together with existing UML-based methods or standalone. The implementation is described and its feasibility and implications are examined by means of a proof-of-concept