@inproceedings{218, abstract = {{In the Image Processing domain, automated generation of complex Image Processing functionality is highly desirable; e.g., for rapid prototyping. Service composition techniques, in turn, facilitate automated generation of complex functionality based on building blocks in terms of services. For that reason, we aim for transferring the Service Composition paradigm into the Image Processing domain. In this paper, we present our symbolic composition approach that enables us to automatically generate Image Processing applications. Functionality of Image Processing services is described by means of a variant of first-order logic, which grounds on domain knowledge operationalized in terms of ontologies. A Petri-net formalism serves as basis for modeling data-flow of services and composed services. A planning-based composition algorithm automatically composes complex data-flow for a required functionality. A brief evaluation serves as proof of concept.}}, author = {{Jungmann, Alexander and Kleinjohann, Bernd}}, booktitle = {{Proceedings of the 13th IEEE International Conference on Services Computing (SCC)}}, pages = {{106----113}}, title = {{{Automatic Composition of Service-based Image Processing Applications}}}, doi = {{10.1109/SCC.2016.21}}, year = {{2016}}, } @inproceedings{5205, author = {{Späth, Johannes and Nguyen Quang Do, Lisa and Ali, Karim and Bodden, Eric}}, booktitle = {{European Conference on Object-Oriented Programming (ECOOP)}}, keywords = {{ATTRACT, ITSECWEBSITE}}, title = {{{Boomerang: Demand-Driven Flow- and Context-Sensitive Pointer Analysis for Java}}}, year = {{2016}}, } @inproceedings{169, abstract = {{We apply methods of genetic programming to a general problem from software engineering, namely example-based generation of specifications. In particular, we focus on model transformation by example. The definition and implementation of model transformations is a task frequently carried out by domain experts, hence, a (semi-)automatic approach is desirable. This application is challenging because the underlying search space has rich semantics, is high-dimensional, and unstructured. Hence, a computationally brute-force approach would be unscalable and potentially infeasible. To address that problem, we develop a sophisticated approach of designing complex mutation operators. We define ‘patterns’ for constructing mutation operators and report a successful case study. Furthermore, the code of the evolved model transformation is required to have high maintainability and extensibility, that is, the code should be easily readable by domain experts. We report an evaluation of this approach in a software engineering case study.}}, author = {{Kühne, Thomas and Hamann, Heiko and Arifulina, Svetlana and Engels, Gregor}}, booktitle = {{Proceedings of the 19th European Conference on Genetic Programming (EuroGP 2016)}}, pages = {{278----293}}, title = {{{Patterns for Constructing Mutation Operators: Limiting the Search Space in a Software Engineering Application}}}, doi = {{10.1007/978-3-319-30668-1_18}}, year = {{2016}}, } @inproceedings{170, abstract = {{We present PAndA2, an extendable, static analysis tool for Android apps which examines permission related security threats like overprivilege, existence of permission redelegation and permission flows. PAndA2 comes along with a textual and graphical visualization of the analysis result and even supports the comparison of analysis results for different android app versions.}}, author = {{Jakobs, Marie-Christine and Töws, Manuel and Pauck, Felix}}, booktitle = {{Workshop on Formal and Model-Driven Techniques for Developing Trustworthy Systems}}, editor = {{Ishikawa F, Romanovsky A, Troubitsyna E}}, title = {{{PAndA 2 : Analyzing Permission Use and Interplay in Android Apps (Tool Paper)}}}, year = {{2016}}, } @phdthesis{1190, author = {{Isenberg, Tobias}}, publisher = {{Universität Paderborn}}, title = {{{Induction-based Verification of Timed Systems}}}, year = {{2016}}, } @inproceedings{158, abstract = {{While requirements focus on how the user interacts with the system, user stories concentrate on the purpose of software features. But in practice, functional requirements are also described in user stories. For this reason, requirements clarification is needed, especially when they are written in natural language and do not stick to any templates (e.g., "as an X, I want Y so that Z ..."). However, there is a lot of implicit knowledge that is not expressed in words. As a result, natural language requirements descriptions may suffer from incompleteness. Existing approaches try to formalize natural language or focus only on entirely missing and not on deficient requirements. In this paper, we therefore present an approach to detect knowledge gaps in user-generated software requirements for interactive requirement clarification: We provide tailored suggestions to the users in order to get more precise descriptions. For this purpose, we identify not fully instantiated predicate argument structures in requirements written in natural language and use context information to realize what was meant by the user.}}, author = {{Bäumer, Frederik Simon and Geierhos, Michaela}}, booktitle = {{Proceedings of the 22nd International Conference on Information and Software Technologies (ICIST)}}, editor = {{Dregvaite, Giedre and Damasevicius, Robertas }}, isbn = {{978-3-319-46253-0}}, keywords = {{Natural language requirements clarification, Syntactically incomplete requirements, Compensatory user stories}}, location = {{Druskininkai, Lithuania}}, pages = {{549--558}}, publisher = {{Springer}}, title = {{{Running out of Words: How Similar User Stories Can Help to Elaborate Individual Natural Language Requirement Descriptions}}}, doi = {{10.1007/978-3-319-46254-7_44}}, volume = {{639}}, year = {{2016}}, } @phdthesis{150, author = {{Arifulina, Svetlana}}, publisher = {{Universität Paderborn}}, title = {{{Solving Heterogeneity for a Successful Service Market}}}, doi = {{10.17619/UNIPB/1-13}}, year = {{2016}}, } @inproceedings{160, abstract = {{A task at the beginning of the software development process is the creation of a requirements specification. The requirements specification is usually created by a software engineering expert. We try to substitute this expert by a domain expert (the user) and formulate the problem of creating requirements specifications as a search-based software engineering problem. The domain expert provides only examples of event sequences that describe the behavior of the required software program. These examples are represented by simple sequence diagrams and are divided into two subsets: positive examples of required program behavior and negative examples of prohibited program behavior. The task is then to synthesize a generalized requirements specification that usefully describes the required software. We approach this problem by applying a genetic algorithm and evolve deterministic finite automata (DFAs). These DFAs take the sequence diagrams as input that should be either accepted (positive example) or rejected (negative example). The problem is neither to find the minimal nor the most general automaton. Instead, the user should be provided with several appropriate automata from which the user can select, or which help the user to refine the examples given initially. We present the context of our research ("On-The-Fly Computing"), present our approach, report results indicating its feasibility, and conclude with a discussion.}}, author = {{van Rooijen, Lorijn and Hamann, Heiko}}, booktitle = {{Proceedings of 24th IEEE International Requirements Engineering Conference (RE 2016)}}, pages = {{3----9}}, title = {{{Requirements Specification-by-Example Using a Multi-Objective Evolutionary Algorithm}}}, doi = {{10.1109/REW.2016.015}}, year = {{2016}}, } @misc{162, author = {{Zhang, Guangli}}, publisher = {{Universität Paderborn}}, title = {{{Program Slicing: A Way of Separating WHILE Programs into Precise and Approximate Portions}}}, year = {{2016}}, } @misc{164, author = {{Czech, Mike}}, publisher = {{Universität Paderborn}}, title = {{{Predicting Rankings of Software Verification Tools Using Kernels for Structured Data}}}, year = {{2016}}, } @phdthesis{140, author = {{Jungmann, Alexander}}, publisher = {{Universität Paderborn}}, title = {{{Towards On-The-Fly Image Processing}}}, year = {{2016}}, } @phdthesis{141, author = {{Mohr, Felix}}, publisher = {{Universität Paderborn}}, title = {{{Towards Automated Service Composition Under Quality Constraints}}}, doi = {{10.17619/UNIPB/1-171}}, year = {{2016}}, } @inproceedings{132, abstract = {{Runtime reconfiguration can be used to replace hardware modules in the field and even to continuously improve them during operation. Runtime reconfiguration poses new challenges for validation, since the required properties of newly arriving modules may be difficult to check fast enough to sustain the intended system dynamics. In this paper we present a method for just-in-time verification of the worst-case completion time of a reconfigurable hardware module. We assume so-called run-to-completion modules that exhibit start and done signals indicating the start and end of execution, respectively. We present a formal verification approach that exploits the concept of proof-carrying hardware. The approach tasks the creator of a hardware module with constructing a proof of the worst-case completion time, which can then easily be checked by the user of the module, just prior to reconfiguration. After explaining the verification approach and a corresponding tool flow, we present results from two case studies, a short term synthesis filter and a multihead weigher. The resultsclearly show that cost of verifying the completion time of the module is paid by the creator instead of the user of the module.}}, author = {{Wiersema, Tobias and Platzner, Marco}}, booktitle = {{Proceedings of the 11th International Symposium on Reconfigurable Communication-centric Systems-on-Chip (ReCoSoC 2016)}}, pages = {{1----8}}, title = {{{Verifying Worst-Case Completion Times for Reconfigurable Hardware Modules using Proof-Carrying Hardware}}}, doi = {{10.1109/ReCoSoC.2016.7533910}}, year = {{2016}}, } @misc{133, abstract = {{.}}, author = {{Dewender, Markus}}, publisher = {{Universität Paderborn}}, title = {{{Verifikation von Service Kompositionen mit Spin}}}, year = {{2016}}, } @misc{134, abstract = {{.}}, author = {{Heinisch, Philipp}}, publisher = {{Universität Paderborn}}, title = {{{Verifikation von Service Kompositionen mit Prolog}}}, year = {{2016}}, } @misc{136, author = {{Vollmers, Daniel}}, publisher = {{Universität Paderborn}}, title = {{{Vergleich von Disambiguierungsansätzen bei Anforderungsbeschreibungen}}}, year = {{2016}}, } @inproceedings{250, abstract = {{Before execution, users should formally validate the correctness of software received from untrusted providers. To accelerate this validation, in the proof carrying code (PCC) paradigm the provider delivers the software together with a certificate, a formal proof of the software’s correctness. Thus, the user only checks if the attached certificate shows correctness of the delivered software.Recently, we introduced configurable program certification, a generic, PCC based framework supporting various software analyses and safety properties. Evaluation of our framework revealed that validation suffers from certificate reading. In this paper, we present two orthogonal approaches which improve certificate validation, both reducing the impact of certificate reading. The first approach reduces the certificate size, storing information only if it cannot easily be recomputed. The second approach partitions the certificate into independently checkable parts. The trick is to read parts of the certificate while already checking read parts. Our experiments show that validation highly benefits from our improvements.}}, author = {{Jakobs, Marie-Christine}}, booktitle = {{Proceedings of the 13th International Conference on Software Engineering and Formal Methods (SEFM)}}, pages = {{159----174}}, title = {{{Speed Up Configurable Certificate Validation by Certificate Reduction and Partitioning}}}, doi = {{10.1007/978-3-319-22969-0_12}}, year = {{2015}}, } @inproceedings{280, abstract = {{The Collaborative Research Centre "On-The-Fly Computing" works on foundations and principles for the vision of the Future Internet. It proposes the paradigm of On-The-Fly Computing, which tackles emerging worldwide service markets. In these markets, service providers trade software, platform, and infrastructure as a service. Service requesters state requirements on services. To satisfy these requirements, the new role of brokers, who are (human) actors building service compositions on the fly, is introduced. Brokers have to specify service compositions formally and comprehensively using a domain-specific language (DSL), and to use service matching for the discovery of the constituent services available in the market. The broker's choice of the DSL and matching approaches influences her success of building compositions as distinctive properties of different service markets play a significant role. In this paper, we propose a new approach of engineering a situation-specific DSL by customizing a comprehensive, modular DSL and its matching for given service market properties. This enables the broker to create market-specific composition specifications and to perform market-specific service matching. As a result, the broker builds service compositions satisfying the requester's requirements more accurately. We evaluated the presented concepts using case studies in service markets for tourism and university management.}}, author = {{Arifulina, Svetlana and Platenius, Marie Christin and Mohr, Felix and Engels, Gregor and Schäfer, Wilhelm}}, booktitle = {{Proceedings of the IEEE 11th World Congress on Services (SERVICES), Visionary Track: Service Composition for the Future Internet}}, pages = {{333----340}}, title = {{{Market-Specific Service Compositions: Specification and Matching}}}, doi = {{10.1109/SERVICES.2015.58}}, year = {{2015}}, } @inproceedings{283, abstract = {{Today, software verification is an established analysis method which can provide high guarantees for software safety. However, the resources (time and/or memory) for an exhaustive verification are not always available, and analysis then has to resort to other techniques, like testing. Most often, the already achieved partial verification results arediscarded in this case, and testing has to start from scratch.In this paper, we propose a method for combining verification and testing in which testing only needs to check the residual fraction of an uncompleted verification. To this end, the partial results of a verification run are used to construct a residual program (and residual assertions to be checked on it). The residual program can afterwards be fed into standardtesting tools. The proposed technique is sound modulo the soundness of the testing procedure. Experimental results show that this combinedusage of verification and testing can significantly reduce the effort for the subsequent testing.}}, author = {{Czech, Mike and Jakobs, Marie-Christine and Wehrheim, Heike}}, booktitle = {{Fundamental Approaches to Software Engineering}}, editor = {{Egyed, Alexander and Schaefer, Ina}}, pages = {{100--114}}, title = {{{Just test what you cannot verify!}}}, doi = {{10.1007/978-3-662-46675-9_7}}, year = {{2015}}, } @inproceedings{285, abstract = {{We propose an incremental workflow for the verification of parameterized systems modeled as symmetric networks of timed automata. Starting with a small number of timed automata in the network, a safety property is verified using IC3, a state-of-the-art algorithm based on induction.The result of the verification, an inductive strengthening, is reused proposing a candidate inductive strengthening for a larger network.If the candidate is valid, our main theorem states that the safety property holds for all sizes of the network of timed automata. Otherwise the number of automata is increased and the next iteration is started with a new run of IC3.We propose and thoroughly examine optimizations to our workflow, e.g. Feedback mechanisms to speed up the run of IC3.}}, author = {{Isenberg, Tobias}}, booktitle = {{Proceedings of the 15th International Conference on Application of Concurrency to System Design (ACSD)}}, pages = {{1--9 }}, title = {{{Incremental Inductive Verification of Parameterized Timed Systems}}}, doi = {{10.1109/ACSD.2015.13}}, year = {{2015}}, }