@phdthesis{89, abstract = {{The vision of OTF Computing is to have the software needs of end users in the future covered by an automatic composition of existing software services. Here we focus on natural language software requirements that end users formulate and submit to OTF providers as requirement specifications. These requirements serve as the sole foundation for the composition of software; but they can be inaccurate and incomplete. Up to now, software developers have identified and corrected these deficits by using a bidirectional consolidation process. However, this type of quality assurance is no longer included in OTF Computing - the classic consolidation process is dropped. This is where this work picks up, dealing with the inaccuracies of freely formulated software design requirements. To do this, we developed the CORDULA (Compensation of Requirements Descriptions Using Linguistic Analysis) system that recognizes and compensates for language deficiencies (e.g., ambiguity, vagueness and incompleteness) in requirements written by inexperienced end users. CORDULA supports the search for suitable software services that can be combined in a composition by transferring requirement specifications into canonical core functionalities. This dissertation provides the first-ever method for holistically recording and improving language deficiencies in user-generated requirement specifications by dealing with ambiguity, incompleteness and vagueness in parallel and in sequence.}}, author = {{Bäumer, Frederik Simon}}, publisher = {{Universität Paderborn}}, title = {{{Indikatorbasierte Erkennung und Kompensation von ungenauen und unvollständig beschriebenen Softwareanforderungen}}}, doi = {{10.17619/UNIPB/1-157}}, year = {{2017}}, } @inproceedings{97, abstract = {{Bridging the gap between informal, imprecise, and vague user requirements descriptions and precise formalized specifications is the main task of requirements engineering. Techniques such as interviews or story telling are used when requirements engineers try to identify a user's needs. The requirements specification process is typically done in a dialogue between users, domain experts, and requirements engineers. In our research, we aim at automating the specification of requirements. The idea is to distinguish between untrained users and trained users, and to exploit domain knowledge learned from previous runs of our system. We let untrained users provide unstructured natural language descriptions, while we allow trained users to provide examples of behavioral descriptions. In both cases, our goal is to synthesize formal requirements models similar to statecharts. From requirements specification processes with trained users, behavioral ontologies are learned which are later used to support the requirements specification process for untrained users. Our research method is original in combining natural language processing and search-based techniques for the synthesis of requirements specifications. Our work is embedded in a larger project that aims at automating the whole software development and deployment process in envisioned future software service markets.}}, author = {{van Rooijen, Lorijn and Bäumer, Frederik Simon and Platenius, Marie Christin and Geierhos, Michaela and Hamann, Heiko and Engels, Gregor}}, booktitle = {{2017 IEEE 25th International Requirements Engineering Conference Workshops (REW)}}, isbn = {{978-1-5386-3489-9}}, keywords = {{Software, Unified modeling language, Requirements engineering, Ontologies, Search problems, Natural languages}}, location = {{Lisbon, Portugal}}, pages = {{379--385}}, publisher = {{IEEE}}, title = {{{From User Demand to Software Service: Using Machine Learning to Automate the Requirements Specification Process}}}, doi = {{10.1109/REW.2017.26}}, year = {{2017}}, } @inproceedings{98, abstract = {{Today, modern IT-systems are often an interplay of third-party web services. Developers in their role as requesters integrate existing services of different providers into new IT-systems. Providers use frameworks like Open API to create syntactic service specifications from which requesters generate code to integrate services. Proper service discovery is crucial to identify usable services in the growing plethora of third-party services. Most advanced service discovery approaches rely on semantic specifications, e.g., OWL-S. While semantic specification is crucial for a precise discovery, syntactical specification is needed for service invocation. To close the gap between semantic and syntactic specifications, service grounding establishes links between the semantic and syntactic specifications. However, for a large number of web services still no semantic specification or grounding exists. In this paper, we present an approach that semi-automates the semantic specification of web services for service providers and additionally helps service requesters to leverage semantic web services. Our approach enables a higher degree of automation than other approaches. This includes the creation of semantic specifications and service groundings for service providers as well as the integration of services for requesters by using our code generator. As proof-of-concept, we provide a case study, where we derive a sophisticated semantic OWL-S specification from a syntactic Open API specification.}}, author = {{Schwichtenberg, Simon and Gerth, Christian and Engels, Gregor}}, booktitle = {{Proceedings of the 24th IEEE International Conference on Web Services (ICWS)}}, pages = {{484----491}}, title = {{{From Open API to Semantic Specifications and Code Adapters}}}, year = {{2017}}, } @inproceedings{99, author = {{Wehrheim, Heike}}, booktitle = {{Proceedings of the 14th International Conference on Formal Aspects of Component Software (FACS)}}, title = {{{Fault localization in service compositions}}}, year = {{2017}}, } @inproceedings{5204, author = {{Späth, Johannes and Ali, Karim and Bodden, Eric}}, booktitle = {{2017 International Conference on Object-Oriented Programming, Languages and Applications (OOPSLA/SPLASH)}}, keywords = {{ATTRACT, ITSECWEBSITE, CROSSING}}, publisher = {{ACM Press}}, title = {{{IDEal: Efficient and Precise Alias-aware Dataflow Analysis}}}, year = {{2017}}, } @article{5209, author = {{Fischer, Andreas and Fuhry, Benny and Kerschbaum, Florian and Bodden, Eric}}, journal = {{CoRR}}, title = {{{Computation on Encrypted Data using Data Flow Authentication}}}, volume = {{abs/1710.00390}}, year = {{2017}}, } @article{68, abstract = {{Proof-carrying hardware (PCH) is a principle for achieving safety for dynamically reconfigurable hardware systems. The producer of a hardware module spends huge effort when creating a proof for a safety policy. The proof is then transferred as a certificate together with the configuration bitstream to the consumer of the hardware module, who can quickly verify the given proof. Previous work utilized SAT solvers and resolution traces to set up a PCH technology and corresponding tool flows. In this article, we present a novel technology for PCH based on inductive invariants. For sequential circuits, our approach is fundamentally stronger than the previous SAT-based one since we avoid the limitations of bounded unrolling. We contrast our technology to existing ones and show that it fits into previously proposed tool flows. We conduct experiments with four categories of benchmark circuits and report consumer and producer runtime and peak memory consumption, as well as the size of the certificates and the distribution of the workload between producer and consumer. Experiments clearly show that our new induction-based technology is superior for sequential circuits, whereas the previous SAT-based technology is the better choice for combinational circuits.}}, author = {{Isenberg, Tobias and Platzner, Marco and Wehrheim, Heike and Wiersema, Tobias}}, journal = {{ACM Transactions on Design Automation of Electronic Systems}}, number = {{4}}, pages = {{61:1----61:23}}, publisher = {{ACM}}, title = {{{Proof-Carrying Hardware via Inductive Invariants}}}, doi = {{10.1145/3054743}}, year = {{2017}}, } @phdthesis{685, author = {{Jakobs, Marie-Christine}}, publisher = {{Universität Paderborn}}, title = {{{On-The-Fly Safety Checking - Customizing Program Certification and Program Restructuring}}}, doi = {{10.17619/UNIPB/1-104}}, year = {{2017}}, } @article{69, abstract = {{Today, software is traded worldwide on global markets, with apps being downloaded to smartphones within minutes or seconds. This poses, more than ever, the challenge of ensuring safety of software in the face of (1) unknown or untrusted software providers together with (2) resource-limited software consumers. The concept of Proof-Carrying Code (PCC), years ago suggested by Necula, provides one framework for securing the execution of untrusted code. PCC techniques attach safety proofs, constructed by software producers, to code. Based on the assumption that checking proofs is usually much simpler than constructing proofs, software consumers should thus be able to quickly check the safety of software. However, PCC techniques often suffer from the size of certificates (i.e., the attached proofs), making PCC techniques inefficient in practice.In this article, we introduce a new framework for the safe execution of untrusted code called Programs from Proofs (PfP). The basic assumption underlying the PfP technique is the fact that the structure of programs significantly influences the complexity of checking a specific safety property. Instead of attaching proofs to program code, the PfP technique transforms the program into an efficiently checkable form, thus guaranteeing quick safety checks for software consumers. For this transformation, the technique also uses a producer-side automatic proof of safety. More specifically, safety proving for the software producer proceeds via the construction of an abstract reachability graph (ARG) unfolding the control-flow automaton (CFA) up to the degree necessary for simple checking. To this end, we combine different sorts of software analysis: expensive analyses incrementally determining the degree of unfolding, and cheap analyses responsible for safety checking. Out of the abstract reachability graph we generate the new program. In its CFA structure, it is isomorphic to the graph and hence another, this time consumer-side, cheap analysis can quickly determine its safety.Like PCC, Programs from Proofs is a general framework instantiable with different sorts of (expensive and cheap) analysis. Here, we present the general framework and exemplify it by some concrete examples. We have implemented different instantiations on top of the configurable program analysis tool CPAchecker and report on experiments, in particular on comparisons with PCC techniques.}}, author = {{Jakobs, Marie-Christine and Wehrheim, Heike}}, journal = {{ACM Transactions on Programming Languages and Systems}}, number = {{2}}, pages = {{7:1--7:56}}, publisher = {{ACM}}, title = {{{Programs from Proofs: A Framework for the Safe Execution of Untrusted Software}}}, doi = {{10.1145/3014427}}, year = {{2017}}, } @misc{106, author = {{Krammer, Isabel}}, publisher = {{Universität München}}, title = {{{Denn wir wissen, was gemeint ist: Erweiterung bestehender Lösungen zur lexikalischen Disambiguierung durch einen kontextsensitiven Whitelist-Ansatz}}}, year = {{2017}}, } @misc{109, author = {{Pauck, Felix}}, publisher = {{Universität Paderborn}}, title = {{{Cooperative static analysis of Android applications}}}, year = {{2017}}, } @article{1098, abstract = {{An end user generally writes down software requirements in ambiguous expressions using natural language; hence, a software developer attuned to programming language finds it difficult to understand th meaning of the requirements. To solve this problem we define semantic categories for disambiguation and classify/annotate the requirement into the categories by using machine-learning models. We extensively use a language frame closely related to such categories for designing features to overcome the problem of insufficient training data compare to the large number of classes. Our proposed model obtained a micro-average F1-score of 0.75, outperforming the previous model, REaCT.}}, author = {{Kim, Yeong-Su and Lee, Seung-Woo and Dollmann, Markus and Geierhos, Michaela}}, issn = {{2205-8494}}, journal = {{International Journal of Software Engineering for Smart Device}}, keywords = {{Natural Language Processing, Semantic Annotation, Machine Learning}}, number = {{2}}, pages = {{1--6}}, publisher = {{Global Vision School Publication}}, title = {{{Semantic Annotation of Software Requirements with Language Frame}}}, volume = {{4}}, year = {{2017}}, } @inproceedings{1180, abstract = {{These days, there is a strong rise in the needs for machine learning applications, requiring an automation of machine learning engineering which is referred to as AutoML. In AutoML the selection, composition and parametrization of machine learning algorithms is automated and tailored to a specific problem, resulting in a machine learning pipeline. Current approaches reduce the AutoML problem to optimization of hyperparameters. Based on recursive task networks, in this paper we present one approach from the field of automated planning and one evolutionary optimization approach. Instead of simply parametrizing a given pipeline, this allows for structure optimization of machine learning pipelines, as well. We evaluate the two approaches in an extensive evaluation, finding both approaches to have their strengths in different areas. Moreover, the two approaches outperform the state-of-the-art tool Auto-WEKA in many settings.}}, author = {{Wever, Marcel Dominik and Mohr, Felix and Hüllermeier, Eyke}}, booktitle = {{27th Workshop Computational Intelligence}}, location = {{Dortmund}}, title = {{{Automatic Machine Learning: Hierachical Planning Versus Evolutionary Optimization}}}, year = {{2017}}, } @misc{119, author = {{Wever, Marcel Dominik}}, publisher = {{Universität Paderborn}}, title = {{{Active Learning of User Requirement Specifications in Dynamic Software Service Markets}}}, year = {{2017}}, } @inproceedings{120, abstract = {{Within software engineering, requirements engineering starts from imprecise and vague user requirements descriptions and infers precise, formalized specifications. Techniques, such as interviewing by requirements engineers, are typically applied to identify the user’s needs. We want to partially automate even this first step of requirements elicitation by methods of evolutionary computation. The idea is to enable users to specify their desired software by listing examples of behavioral descriptions. Users initially specify two lists of operation sequences, one with desired behaviors and one with forbidden behaviors. Then, we search for the appropriate formal software specification in the form of a deterministic finite automaton. We solve this problem known as grammatical inference with an active coevolutionary approach following Bongard and Lipson [2]. The coevolutionary process alternates between two phases: (A) additional training data is actively proposed by an evolutionary process and the user is interactively asked to label it; (B) appropriate automata are then evolved to solve this extended grammatical inference problem. Our approach leverages multi-objective evolution in both phases and outperforms the state-of-the-art technique [2] for input alphabet sizes of three and more, which are relevant to our problem domain of requirements specification.}}, author = {{Wever, Marcel Dominik and van Rooijen, Lorijn and Hamann, Heiko}}, booktitle = {{Proceedings of the Genetic and Evolutionary Computation Conference (GECCO)}}, pages = {{1327----1334}}, title = {{{Active Coevolutionary Learning of Requirements Specifications from Examples}}}, doi = {{10.1145/3071178.3071258}}, year = {{2017}}, } @misc{100, author = {{Sergio Djoum Temdjim, Albin}}, publisher = {{Universität Paderborn}}, title = {{{Evaluation of Software Reputation Matching Based on App Reviews}}}, year = {{2017}}, } @misc{101, author = {{Rehmer, Lennart}}, publisher = {{Universität Paderborn}}, title = {{{Erweiterung eines kontextsensitiven Autovervollständigungstools zur natürlichsprachlichen Softwarespezifikation}}}, year = {{2017}}, } @phdthesis{102, author = {{Becker, Matthias}}, publisher = {{Universität Paderborn}}, title = {{{Engineering Self-Adaptive Systems with Simulation-Based Performence Prediction}}}, doi = {{10.17619/UNIPB/1-133}}, year = {{2017}}, } @phdthesis{195, author = {{Platenius, Marie Christin}}, publisher = {{Universität Paderborn}}, title = {{{Fuzzy Matching of Comprehensive Service Specifications}}}, year = {{2016}}, } @misc{197, author = {{Dollmann, Markus}}, publisher = {{Universität Paderborn}}, title = {{{Frag die Anwender: Extraktion und Klassifikation von funktionalen Softwareanforderungen aus User-Generated-Content}}}, year = {{2016}}, }