International PhD Program in Software Engineering
The JKU International PhD Program in Software Engineering supports national and international PhD students at the Johannes Kepler University Linz (JKU). Students are integrated in the normal Doctorate Degree Program in Technical Sciences at the Faculty of Engineering and Natural Sciences. The normative length of the program is 6 semesters (3 years), although students may take longer if required.
The PhD program is sponsored by the FWF and other sources. Students are granted the personnel cost rates defined by FWF for Doctoral candidates (which correspond to University employment of 30h/week employment with the remaining 10h/week intended for independent writing of the material leading towards the PhD thesis).
We currently have an open application phase. National and international candidates with a Master's degree in computer science or closely related areas may apply for one of the defined research areas listed below. Please send your application including CV, motivation letter, and references to firstname.lastname@example.org, including the title of the research project. Please also submit a project proposal covering your motivation and research interests, and additional material strengthening your application.
Engineering in the Cloud – A New Dimension of Collaboration and Cooperation
The engineering of systems is unimaginable without software tools. Engineers use them to capture and analyze engineering problems; specify, implement, test, and maintain engineering solutions, and manage engineering processes. Yet, there is a gap between the needs of independently working engineers and the needs of a collaborative engineering team. The existing tool landscape emphasizes the former. Most engineering tools are single-user applications – often of excellent quality but limited in that they support the works of individuals and not that of a group. However, existing engineering practices place the burden of collaboration on engineers who lack awareness. This problem has been a significant contributor to many high profile engineering failures and it has shaped two beliefs: 1) the future requires integrated engineering tools and 2) tool integration problems can only be overcome through large standardization efforts (covering interoperability, meta models, ontologies, tool chains, and transformations). Collaborative Engineering in a Multi-Tool Environment (DesignSpace) embraces the first belief but rejects the second one. Standardization is very important for engineering but over-standardization forces compromises and favors established routines – both stifling innovation and creativity. The DesignSpace project invisions that engineering strength comes from tool diversity. To achieve a breakthrough in engineering, the next generation of engineering environments does not require better tools but innovative ways on how engineers collaborate using the tools they already have. Tool quality alone cannot guarantee engineering quality. What the existing tool landscape misses is how knowledge flows among engineers and the tools they use. Without this knowledge, engineers cannot effectively visualize the bigger picture, propagate changes among tools, and detect errors. This is known as the tool interoperability problem and it is the most critical software and systems engineering problem today. The DesignSpace bridges the gap between single-user tools and collaborative engineering environments by providing engineers with flexible cross-tool sharing, transformation, linking (traceability), and guidance (e.g. inconsistency detection) to enable multi-user collaboration on an unprecedented scale. In terms of ongoing integration efforts, the DesignSpace is a breakthrough in that it does not affect which tools engineers use or how they use them..
Reuse: Mining and Evolving Variability in Software-Intensive Systems
With the advent of technologies such as the internet and mobile computing, developing software-based products as one-of-a-kind standalone products is no longer economically feasible. Instead, modern software must be designed to execute in multiple environments (hardware and software platforms) and different contexts (e.g. desktop or mobile), interact with other software products and can even be part of larger software ecosystems. These and other technological and economic trends are changing the way software is developed from a product-centric perspective to product portfolios of similar software products that are tailored to varying, customer-specific requirements.
However, efficiently developing software product portfolios is not an easy endeavour. The most common scenario is when portfolios are reverse-engineered from a diverse pool of existing variants of software products that were created with ad hoc techniques. These techniques are collectively called Clone and Own (C&O), and commonly rely on manual, undisciplined, and generally undocumented development practices. Not surprisingly, even when dealing with a small number of variants, C&O approaches lead to maintenance problems like inefficient bug fixing, wrong feature updates, duplicated functionality, and redundant and inadequate testing. All these factors inevitably result in low-quality software with performance and functionality faults and limitations, and render software companies unable to cope with fast-evolving functionality requirements or technological advances.
The main goal of the proposed project is to develop an integrated framework capable of providing scalable, robust, flexible, extensible, and automated support for the effective management of software products portfolios. Our works aims to provide a more formal and methodological footing to C&O practices such that their shortcomings are properly addressed. The approach that we propose is incremental and has no hefty upfront investment in the production of the first consolidated portfolio compared to traditional product lines. This fact enables adopters to reap benefits early on and continuously.
The framework envisioned will orchestrate and extend works from several important research areas in software engineering, e.g. automated software repair and search based software engineering that rely on novel algorithms inspired by nature to solve complex engineering problems. The proposed project aims to develop software tools and techniques, and provide adequate guidance and best practices identified through their application in case studies from academia and local industry.
Model-Driven Engineering to Ensure Correct System Behavior at Runtime
Software systems have complex behavior and it is critical to ensure that this behavior conforms to the goals set forth by their customers and users. Take, for example, a video on demand player (VOD) that lets users select and playback movies. Such as system responds to given stimuli for example, it starts playing a movie (response) when a user presses the play button (stimuli). Today, the correctness of such a system is demonstrated through testing but testing is time consuming because one needs to explore all possible ways of using a system with near infinite possibilities. Each test has to be hand written where a developer must decide the responses for every possible combination of stimuli. A very expensive and even error prone task. This work investigates how models can help in validating a system’s correct behavior. Today, developers create models during the initial development activities to help transition a system’s requirements to code but these models are often not used during testing. This is a missed opportunity because models can describe system behavior and this model behavior could also be useful for testing a system at runtime. For example, state machines let developers model valid sequences of stimuli and responses. In context of our VOD example, a state machine could define that the playing of a movie (i.e., pressing the play button) must be preceded by a user selecting a movie beforehand. However, it is not straightforward to use such models to help test a system because models tend to be at a much higher level of abstraction. This work thus needs to solve how to overcome this difference in abstraction and also address problems related to traceability. For example, models can only be used for testing a system if we understand where and how the various model elements are implemented in the system.