12 Search Results for "Apel, Sven"

Document
DOI: 10.4230/LIPIcs.ECOOP.2024.9
A Language-Based Version Control System for Python

Authors: Luís Carvalho and João Costa Seco

Published in: LIPIcs, Volume 313, 38th European Conference on Object-Oriented Programming (ECOOP 2024)

Abstract
We extend prior work on a language-based approach to versioned software development to support versioned programs with mutable state and evolving method interfaces. Unlike the traditional approach of mainstream version control systems, where a textual diff represents each evolution step, we treat versions as programming elements. Each evolution step, merge operation, and version relationship is represented explicitly in a multifaceted code representation. This provides static guarantees for safe code reuse from previous versions and forward and backwards compatibility between versions, allowing clients to use newly introduced code without needing to refactor their program manually. By lifting versioning to the language level, we pave the way for tools that interact with software repositories to have more insight into a system’s behavior evolution. We instantiate our work in the Python programming language and demonstrate its applicability regarding common evolution and refactoring patterns found in different versions of popular Python packages.
Cite as

Luís Carvalho and João Costa Seco. A Language-Based Version Control System for Python. In 38th European Conference on Object-Oriented Programming (ECOOP 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 313, pp. 9:1-9:27, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)

Copy BibTex To Clipboard

@InProceedings{carvalho_et_al:LIPIcs.ECOOP.2024.9,
  author =	{Carvalho, Lu{\'\i}s and Costa Seco, Jo\~{a}o},
  title =	{{A Language-Based Version Control System for Python}},
  booktitle =	{38th European Conference on Object-Oriented Programming (ECOOP 2024)},
  pages =	{9:1--9:27},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-341-6},
  ISSN =	{1868-8969},
  year =	{2024},
  volume =	{313},
  editor =	{Aldrich, Jonathan and Salvaneschi, Guido},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2024.9},
  URN =		{urn:nbn:de:0030-drops-208586},
  doi =		{10.4230/LIPIcs.ECOOP.2024.9},
  annote =	{Keywords: Software evolution, type theory}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2024.12
Mutation-Based Lifted Repair of Software Product Lines

Authors: Aleksandar S. Dimovski

Published in: LIPIcs, Volume 313, 38th European Conference on Object-Oriented Programming (ECOOP 2024)

Abstract
This paper presents a novel lifted repair algorithm for program families (Software Product Lines - SPLs) based on code mutations. The inputs of our algorithm are an erroneous SPL and a specification given in the form of assertions. We use variability encoding to transform the given SPL into a single program, called family simulator, which is translated into a set of SMT formulas whose conjunction is satisfiable iff the simulator (i.e., the input SPL) violates an assertion. We use a predefined set of mutations applied to feature and program expressions of the given SPL. The algorithm repeatedly mutates the erroneous family simulator and checks if it becomes (bounded) correct. Since mutating an expression corresponds to mutating a formula in the set of SMT formulas encoding the family simulator, the search for a correct mutant is reduced to searching an unsatisfiable set of SMT formulas. To efficiently explore the huge state space of mutants, we call SAT and SMT solvers in an incremental way. The outputs of our algorithm are all minimal repairs in the form of minimal number of (feature and program) expression replacements such that the repaired SPL is (bounded) correct with respect to a given set of assertions. We have implemented our algorithm in a prototype tool and evaluated it on a set of #ifdef-based C programs (i.e., annotative SPLs). The experimental results show that our approach is able to successfully repair various interesting SPLs.
Cite as

Aleksandar S. Dimovski. Mutation-Based Lifted Repair of Software Product Lines. In 38th European Conference on Object-Oriented Programming (ECOOP 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 313, pp. 12:1-12:24, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)

Copy BibTex To Clipboard

@InProceedings{dimovski:LIPIcs.ECOOP.2024.12,
  author =	{Dimovski, Aleksandar S.},
  title =	{{Mutation-Based Lifted Repair of Software Product Lines}},
  booktitle =	{38th European Conference on Object-Oriented Programming (ECOOP 2024)},
  pages =	{12:1--12:24},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-341-6},
  ISSN =	{1868-8969},
  year =	{2024},
  volume =	{313},
  editor =	{Aldrich, Jonathan and Salvaneschi, Guido},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2024.12},
  URN =		{urn:nbn:de:0030-drops-208613},
  doi =		{10.4230/LIPIcs.ECOOP.2024.12},
  annote =	{Keywords: Program repair, Software Product Lines, Code mutations, Variability encoding}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2024.21
Learning Gradual Typing Performance

Authors: Mohammad Wahiduzzaman Khan, Sheng Chen, and Yi He

Published in: LIPIcs, Volume 313, 38th European Conference on Object-Oriented Programming (ECOOP 2024)

Abstract
Gradual typing has emerged as a promising typing discipline for reconciling static and dynamic typing, which have respective strengths and shortcomings. Thanks to its promises, gradual typing has gained tremendous momentum in both industry and academia. A main challenge in gradual typing is that, however, the performance of its programs can often be unpredictable, and adding or removing the type of a a single parameter may lead to wild performance swings. Many approaches have been proposed to optimize gradual typing performance, but little work has been done to aid the understanding of the performance landscape of gradual typing and navigating the migration process (which adds type annotations to make programs more static) to avert performance slowdowns. Motivated by this situation, this work develops a machine-learning-based approach to predict the performance of each possible way of adding type annotations to a program. On top of that, many supports for program migrations could be developed, such as finding the most performant neighbor of any given configuration. Our approach gauges runtime overheads of dynamic type checks inserted by gradual typing and uses that information to train a machine learning model, which is used to predict the running time of gradual programs. We have evaluated our approach on 12 Python benchmarks for both guarded and transient semantics. For guarded semantics, our evaluation results indicate that with only 40 training instances generated from each benchmark, the predicted times for all other instances differ on average by 4% from the measured times. For transient semantics, the time difference ratio is higher but the time difference is often within 0.1 seconds.
Cite as

Mohammad Wahiduzzaman Khan, Sheng Chen, and Yi He. Learning Gradual Typing Performance. In 38th European Conference on Object-Oriented Programming (ECOOP 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 313, pp. 21:1-21:27, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)

Copy BibTex To Clipboard

@InProceedings{khan_et_al:LIPIcs.ECOOP.2024.21,
  author =	{Khan, Mohammad Wahiduzzaman and Chen, Sheng and He, Yi},
  title =	{{Learning Gradual Typing Performance}},
  booktitle =	{38th European Conference on Object-Oriented Programming (ECOOP 2024)},
  pages =	{21:1--21:27},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-341-6},
  ISSN =	{1868-8969},
  year =	{2024},
  volume =	{313},
  editor =	{Aldrich, Jonathan and Salvaneschi, Guido},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2024.21},
  URN =		{urn:nbn:de:0030-drops-208706},
  doi =		{10.4230/LIPIcs.ECOOP.2024.21},
  annote =	{Keywords: Gradual typing performance, type migration, performance prediction, machine learning}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2024.36
Scaling Interprocedural Static Data-Flow Analysis to Large C/C++ Applications: An Experience Report

Authors: Fabian Schiebel, Florian Sattler, Philipp Dominik Schubert, Sven Apel, and Eric Bodden

Published in: LIPIcs, Volume 313, 38th European Conference on Object-Oriented Programming (ECOOP 2024)

Abstract
Interprocedural data-flow analysis is important for computing precise information on whole programs. In theory, the popular algorithmic framework interprocedural distributive environments (IDE) provides a tool to solve distributive interprocedural data-flow problems efficiently. Yet, unfortunately, available state-of-the-art implementations of the IDE framework start to run into scalability issues for programs with several thousands of lines of code, depending on the static analysis domain. Since the IDE framework is a basic building block for many static program analyses, this presents a serious limitation. In this paper, we report on our experience with making the IDE algorithm scale to C/C++ applications with up to 500 000 lines of code. We analyze the IDE algorithm and its state-of-the-art implementations to identify their weaknesses related to scalability at both a conceptual and implementation level. Based on this analysis, we propose several optimizations to overcome these weaknesses, aiming at a sweet spot between reducing running time and memory consumption. As a result, we provide an improved IDE solver that implements our optimizations within the PhASAR static analysis framework. Our evaluation on real-world C/C++ applications shows that applying the optimizations speeds up the analysis on average by up to 7×, while also reducing memory consumption by 7× on average as well. For the first time, these optimizations allow us to analyze programs with several hundreds of thousands of lines of LLVM-IR code in reasonable time and space.
Cite as

Fabian Schiebel, Florian Sattler, Philipp Dominik Schubert, Sven Apel, and Eric Bodden. Scaling Interprocedural Static Data-Flow Analysis to Large C/C++ Applications: An Experience Report. In 38th European Conference on Object-Oriented Programming (ECOOP 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 313, pp. 36:1-36:28, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)

Copy BibTex To Clipboard

@InProceedings{schiebel_et_al:LIPIcs.ECOOP.2024.36,
  author =	{Schiebel, Fabian and Sattler, Florian and Schubert, Philipp Dominik and Apel, Sven and Bodden, Eric},
  title =	{{Scaling Interprocedural Static Data-Flow Analysis to Large C/C++ Applications: An Experience Report}},
  booktitle =	{38th European Conference on Object-Oriented Programming (ECOOP 2024)},
  pages =	{36:1--36:28},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-341-6},
  ISSN =	{1868-8969},
  year =	{2024},
  volume =	{313},
  editor =	{Aldrich, Jonathan and Salvaneschi, Guido},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2024.36},
  URN =		{urn:nbn:de:0030-drops-208859},
  doi =		{10.4230/LIPIcs.ECOOP.2024.36},
  annote =	{Keywords: Interprocedural data-flow analysis, IDE, LLVM, C/C++}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2024.47
Defining Name Accessibility Using Scope Graphs

Authors: Aron Zwaan and Casper Bach Poulsen

Published in: LIPIcs, Volume 313, 38th European Conference on Object-Oriented Programming (ECOOP 2024)

Abstract
Many programming languages allow programmers to regulate accessibility; i.e., annotating a declaration with keywords such as export and private to indicate where it can be accessed. Despite the importance of name accessibility for, e.g., compilers, editor auto-completion and tooling, and automated refactorings, few existing type systems provide a formal account of name accessibility. We present a declarative, executable, and language-parametric model for name accessibility, which provides a formal specification of name accessibility in Java, C#, C++, Rust, and Eiffel. We achieve this by defining name accessibility as a predicate on resolution paths through scope graphs. Since scope graphs are a language-independent model of name resolution, our model provides a uniform approach to defining different accessibility policies for different languages. Our model is implemented in Statix, a logic language for executable type system specification using scope graphs. We evaluate its correctness on a test suite that compares it with the C#, Java, and Rust compilers, and show we can synthesize access modifiers in programs with holes accurately.
Cite as

Aron Zwaan and Casper Bach Poulsen. Defining Name Accessibility Using Scope Graphs. In 38th European Conference on Object-Oriented Programming (ECOOP 2024). Leibniz International Proceedings in Informatics (LIPIcs), Volume 313, pp. 47:1-47:29, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)

Copy BibTex To Clipboard

@InProceedings{zwaan_et_al:LIPIcs.ECOOP.2024.47,
  author =	{Zwaan, Aron and Bach Poulsen, Casper},
  title =	{{Defining Name Accessibility Using Scope Graphs}},
  booktitle =	{38th European Conference on Object-Oriented Programming (ECOOP 2024)},
  pages =	{47:1--47:29},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-341-6},
  ISSN =	{1868-8969},
  year =	{2024},
  volume =	{313},
  editor =	{Aldrich, Jonathan and Salvaneschi, Guido},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2024.47},
  URN =		{urn:nbn:de:0030-drops-208961},
  doi =		{10.4230/LIPIcs.ECOOP.2024.47},
  annote =	{Keywords: access modifier, visibility, scope graph, name resolution}
}
Document
Artifact
DOI: 10.4230/DARTS.10.2.5
Mutation-Based Lifted Repair of Software Product Lines (Artifact)

Authors: Aleksandar S. Dimovski

Published in: DARTS, Volume 10, Issue 2, Special Issue of the 38th European Conference on Object-Oriented Programming (ECOOP 2024)

Abstract
In this work, we describe the installation, usage, and evaluation results of the tool SPLAllRepair, which is introduced by the paper "Mutation-based Lifted Repair of Software Product Lines". We provide step-by-step instructions on how to download, run, and compare the tool’s outputs to outputs described in the paper. The tool implements a novel lifted repair algorithm for program families (Software Product Lines - SPLs) based on code mutations. The inputs of our algorithm are an erroneous SPL and a specification given in the form of assertions. We use variability encoding to transform the given SPL into a single program, called family simulator, which is translated into a set of SMT formulas whose conjunction is satisfiable iff the simulator (i.e. the input SPL) violates an assertion. We use a predefined set of mutations applied to feature and program expressions of the given SPL. The algorithm repeatedly mutates the erroneous family simulator and checks if it becomes (bounded) correct. The outputs are all minimal repairs in the form of minimal number of (feature and program) expression replacements such that the repaired SPL is (bounded) correct with respect to a given set of assertions. We present the experimental results showing that our approach is able to successfully repair various interesting #ifdef-based C SPLs.
Cite as

Aleksandar S. Dimovski. Mutation-Based Lifted Repair of Software Product Lines (Artifact). In Special Issue of the 38th European Conference on Object-Oriented Programming (ECOOP 2024). Dagstuhl Artifacts Series (DARTS), Volume 10, Issue 2, pp. 5:1-5:5, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2024)

Copy BibTex To Clipboard

@Article{dimovski:DARTS.10.2.5,
  author =	{Dimovski, Aleksandar S.},
  title =	{{Mutation-Based Lifted Repair of Software Product Lines (Artifact)}},
  pages =	{5:1--5:5},
  journal =	{Dagstuhl Artifacts Series},
  ISBN =	{978-3-95977-342-3},
  ISSN =	{2509-8195},
  year =	{2024},
  volume =	{10},
  number =	{2},
  editor =	{Dimovski, Aleksandar S.},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DARTS.10.2.5},
  URN =		{urn:nbn:de:0030-drops-209036},
  doi =		{10.4230/DARTS.10.2.5},
  annote =	{Keywords: Program repair, Software Product Lines, Code mutations, Variability encoding}
}
Document
DOI: 10.4230/LIPIcs.ECOOP.2021.14
Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation

Authors: Aleksandar S. Dimovski and Sven Apel

Published in: LIPIcs, Volume 194, 35th European Conference on Object-Oriented Programming (ECOOP 2021)

Abstract
Program families (software product lines) are increasingly adopted by industry for building families of related software systems. A program family offers a set of features (configured options) to control the presence and absence of software functionality. Features in program families are often assigned at compile-time, so their values can only be read at run-time. However, today many program families and application domains demand run-time adaptation, reconfiguration, and post-deployment tuning. Dynamic program families (dynamic software product lines) have emerged as an attempt to handle variability at run-time. Features in dynamic program families can be controlled by ordinary program variables, so reads and writes to them may happen at run-time. Recently, a decision tree lifted domain for analyzing traditional program families with numerical features has been proposed, in which decision nodes contain linear constraints defined over numerical features and leaf nodes contain analysis properties defined over program variables. Decision nodes partition the configuration space of possible feature values, while leaf nodes provide analysis information corresponding to each partition of the configuration space. As features are statically assigned at compile-time, decision nodes can be added, modified, and deleted only when analyzing read accesses of features. In this work, we extend the decision tree lifted domain so that it can be used to efficiently analyze dynamic program families with numerical features. Since features can now be changed at run-time, decision nodes can be modified when handling read and write accesses of feature variables. For this purpose, we define extended transfer functions for assignments and tests as well as a special widening operator to ensure termination of the lifted analysis. To illustrate the potential of this approach, we have implemented a lifted static analyzer, called DSPLNum²Analyzer, for inferring numerical invariants of dynamic program families written in C. An empirical evaluation on benchmarks from SV-COMP indicates that our tool is effective and provides a flexible way of adjusting the precision/cost ratio in static analysis of dynamic program families.
Cite as

Aleksandar S. Dimovski and Sven Apel. Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation. In 35th European Conference on Object-Oriented Programming (ECOOP 2021). Leibniz International Proceedings in Informatics (LIPIcs), Volume 194, pp. 14:1-14:28, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)

Copy BibTex To Clipboard

@InProceedings{dimovski_et_al:LIPIcs.ECOOP.2021.14,
  author =	{Dimovski, Aleksandar S. and Apel, Sven},
  title =	{{Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation}},
  booktitle =	{35th European Conference on Object-Oriented Programming (ECOOP 2021)},
  pages =	{14:1--14:28},
  series =	{Leibniz International Proceedings in Informatics (LIPIcs)},
  ISBN =	{978-3-95977-190-0},
  ISSN =	{1868-8969},
  year =	{2021},
  volume =	{194},
  editor =	{M{\o}ller, Anders and Sridharan, Manu},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ECOOP.2021.14},
  URN =		{urn:nbn:de:0030-drops-140572},
  doi =		{10.4230/LIPIcs.ECOOP.2021.14},
  annote =	{Keywords: Dynamic program families, Static analysis, Abstract interpretation, Decision tree lifted domain}
}
Document
Artifact
DOI: 10.4230/DARTS.7.2.6
Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation (Artifact)

Authors: Aleksandar S. Dimovski and Sven Apel

Published in: DARTS, Volume 7, Issue 2, Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021)

Abstract
In this article, we describe the usage and evaluation results of the tool DSPLNum²Analyzer introduced by the paper "Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation". We provide step-by-step instructions on how to download, install, run, and compare the tool’s outputs to outputs described in the paper. DSPLNum²Analyzer is a research prototype lifted static analyzer based on abstract interpretation designed for performing numerical static analysis of dynamic C program families.
Cite as

Aleksandar S. Dimovski and Sven Apel. Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation (Artifact). In Special Issue of the 35th European Conference on Object-Oriented Programming (ECOOP 2021). Dagstuhl Artifacts Series (DARTS), Volume 7, Issue 2, pp. 6:1-6:6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2021)

Copy BibTex To Clipboard

@Article{dimovski_et_al:DARTS.7.2.6,
  author =	{Dimovski, Aleksandar S. and Apel, Sven},
  title =	{{Lifted Static Analysis of Dynamic Program Families by Abstract Interpretation (Artifact)}},
  pages =	{6:1--6:6},
  journal =	{Dagstuhl Artifacts Series},
  ISSN =	{2509-8195},
  year =	{2021},
  volume =	{7},
  number =	{2},
  editor =	{Dimovski, Aleksandar S. and Apel, Sven},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DARTS.7.2.6},
  URN =		{urn:nbn:de:0030-drops-140303},
  doi =		{10.4230/DARTS.7.2.6},
  annote =	{Keywords: Dynamic program families, Static analysis, Abstract interpretation, Decision tree lifted domain}
}
Document
DOI: 10.4230/DagRep.4.7.1
Feature Interactions: The Next Generation (Dagstuhl Seminar 14281)

Authors: Sven Apel, Joanne M. Atlee, Luciano Baresi, and Pamela Zave

Published in: Dagstuhl Reports, Volume 4, Issue 7 (2014)

Abstract
The feature-interaction problem is a major threat to modularity and impairs compositional development and reasoning. A feature interaction occurs when the behavior of one feature is affected by the presence of another feature; often it cannot be deduced easily from the behaviors of the individual features involved. The feature-interaction problem became a crisis in the telecommunications industry in the late 1980s, and researchers responded with formalisms that enable automatic detection of feature interactions, architectures that avoid classes of interactions, and techniques for resolving interactions at run-time. While this pioneering work was foundational and very successful, it is limited in the sense that it is based on assumptions that hold only for telecommunication systems. In the meantime, different notions of feature interactions have emerged in different communities, including Internet applications, service systems, adaptive systems, automotive systems, software product lines, requirements engineering, and computational biology. So, feature interactions are a much more general concept than investigated in the past in the context of telecommunication systems, but a classification, comparison, and generalization of the multitude of different views is missing. The feature-interaction problem is still of pivotal importance in various industrial applications, and the Dagstuhl seminar "Feature Interactions: The Next Generation" gathered researchers and practitioners from different areas of computer science and other disciplines with the goal to compare, discuss, and consolidate their views, experience, and domain-specific solutions to the feature-interaction problem.
Cite as

Sven Apel, Joanne M. Atlee, Luciano Baresi, and Pamela Zave. Feature Interactions: The Next Generation (Dagstuhl Seminar 14281). In Dagstuhl Reports, Volume 4, Issue 7, pp. 1-24, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2014)

Copy BibTex To Clipboard

@Article{apel_et_al:DagRep.4.7.1,
  author =	{Apel, Sven and Atlee, Joanne M. and Baresi, Luciano and Zave, Pamela},
  title =	{{Feature Interactions: The Next Generation (Dagstuhl Seminar 14281)}},
  pages =	{1--24},
  journal =	{Dagstuhl Reports},
  ISSN =	{2192-5283},
  year =	{2014},
  volume =	{4},
  number =	{7},
  editor =	{Apel, Sven and Atlee, Joanne M. and Baresi, Luciano and Zave, Pamela},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagRep.4.7.1},
  URN =		{urn:nbn:de:0030-drops-47830},
  doi =		{10.4230/DagRep.4.7.1},
  annote =	{Keywords: Feature interactions, feature-interaction problem, feature orientation, product lines, modularity, composition}
}
Document
DOI: 10.4230/DagRep.1.1.27
Feature-Oriented Software Development (FOSD) (Dagstuhl Seminar 11021)

Authors: Sven Apel, William Cook, Krzysztof Czarnecki, and Oscar Nierstrasz

Published in: Dagstuhl Reports, Volume 1, Issue 1 (2011)

Abstract
This report documents the program and the outcomes of Dagstuhl Seminar 11021 "Feature-Oriented Software Development (FOSD)". FOSD is an emerging paradigm that aims at increasing the level of automation, reuse, and variation in software development. The main goal of the Dagstuhl seminar on FOSD was to gather researchers and practitioners who are active in different communities to discuss the roots, state of the art, and future directions of FOSD research and practice. Additional goals were to strengthen the identity of the feature orientation community and to relate FOSD to other software development paradigms. The report contains an executive summary, abstracts of the talks held during the seminar, and summaries of special sessions.
Cite as

Sven Apel, William Cook, Krzysztof Czarnecki, and Oscar Nierstrasz. Feature-Oriented Software Development (FOSD) (Dagstuhl Seminar 11021). In Dagstuhl Reports, Volume 1, Issue 1, pp. 27-41, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2011)

Copy BibTex To Clipboard

@Article{apel_et_al:DagRep.1.1.27,
  author =	{Apel, Sven and Cook, William and Czarnecki, Krzysztof and Nierstrasz, Oscar},
  title =	{{Feature-Oriented Software Development (FOSD) (Dagstuhl Seminar 11021)}},
  pages =	{27--41},
  journal =	{Dagstuhl Reports},
  ISSN =	{2192-5283},
  year =	{2011},
  volume =	{1},
  number =	{1},
  editor =	{Apel, Sven and Cook, William and Czarnecki, Krzysztof and Nierstrasz, Oscar},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagRep.1.1.27},
  URN =		{urn:nbn:de:0030-drops-31414},
  doi =		{10.4230/DagRep.1.1.27},
  annote =	{Keywords: FOSD, automation, software family}
}
Document
DOI: 10.4230/DagSemProc.08281.1
08281 Abstracts Collection – Software Engineering for Trailor-made Data Management

Authors: Sven Apel, Don Batory, Goetz Graefe, Gunter Saake, and Olaf Spinczyk

Published in: Dagstuhl Seminar Proceedings, Volume 8281, Software Engineering for Tailor-made Data Management (2008)

Abstract
From July 6th to July 11th, 2008, the Dagstuhl Seminar 08281 ``Software Engineering for Tailor-made Data Management'' was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar as well as abstracts of seminar results and ideas are put together in this paper. The first section describes the seminar topics and goals in general. Links to extended abstracts or full papers are provided, if available.
Cite as

Sven Apel, Don Batory, Goetz Graefe, Gunter Saake, and Olaf Spinczyk. 08281 Abstracts Collection – Software Engineering for Trailor-made Data Management. In Software Engineering for Tailor-made Data Management. Dagstuhl Seminar Proceedings, Volume 8281, pp. 1-13, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2008)

Copy BibTex To Clipboard

@InProceedings{apel_et_al:DagSemProc.08281.1,
  author =	{Apel, Sven and Batory, Don and Graefe, Goetz and Saake, Gunter and Spinczyk, Olaf},
  title =	{{08281  Abstracts Collection – Software Engineering for Trailor-made Data Management}},
  booktitle =	{Software Engineering for Tailor-made Data Management},
  pages =	{1--13},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2008},
  volume =	{8281},
  editor =	{Sven Apel and Don Batory and Goetz Graefe and Gunter Saake and Olaf Spynczyk},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.08281.1},
  URN =		{urn:nbn:de:0030-drops-15796},
  doi =		{10.4230/DagSemProc.08281.1},
  annote =	{Keywords: Software Engineering, Data Management, Software Product Lines, Embedded Systems}
}
Document
DOI: 10.4230/DagSemProc.08281.2
08281 Executive Summary – Software Engineering for Tailor-made Data Management

Authors: Sven Apel, Don Batory, Goetz Graefe, Gunter Saake, and Olaf Spinczyk

Published in: Dagstuhl Seminar Proceedings, Volume 8281, Software Engineering for Tailor-made Data Management (2008)

Abstract
Tailor-made data management software (DMS) is not only important in the field of embedded systems. DMS that incorporates only features that are required bear the potential to strip down the code base and to improve reliability and maintainability. In the past 20 years several new technologies have emerged that aim at lean, efficient, and well-structured software, which should also be applicable to DMS. In the Dagstuhl Seminar ``Software Engineering for Tailor-made Data Management'', July 6h to July 11th, 2008, 29 researchers from 7 countries discussed the development, application, and assessment of these new technologies in the context of DMS.
Cite as

Sven Apel, Don Batory, Goetz Graefe, Gunter Saake, and Olaf Spinczyk. 08281 Executive Summary – Software Engineering for Tailor-made Data Management. In Software Engineering for Tailor-made Data Management. Dagstuhl Seminar Proceedings, Volume 8281, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2008)

Copy BibTex To Clipboard

@InProceedings{apel_et_al:DagSemProc.08281.2,
  author =	{Apel, Sven and Batory, Don and Graefe, Goetz and Saake, Gunter and Spinczyk, Olaf},
  title =	{{08281 Executive Summary – Software Engineering for Tailor-made Data Management}},
  booktitle =	{Software Engineering for Tailor-made Data Management},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2008},
  volume =	{8281},
  editor =	{Sven Apel and Don Batory and Goetz Graefe and Gunter Saake and Olaf Spynczyk},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.08281.2},
  URN =		{urn:nbn:de:0030-drops-15780},
  doi =		{10.4230/DagSemProc.08281.2},
  annote =	{Keywords: Software Engineering, Data Management, Tailoring, Embedded Systems}
}
  • Refine by Author
  • 7 Apel, Sven
  • 4 Dimovski, Aleksandar S.
  • 2 Batory, Don
  • 2 Graefe, Goetz
  • 2 Saake, Gunter
  • Show More...

  • Refine by Classification
  • 4 Software and its engineering → Software product lines
  • 4 Theory of computation → Abstraction
  • 2 Software and its engineering → Software functional properties
  • 1 Computing methodologies → Learning linear models
  • 1 Computing methodologies → Machine learning
  • Show More...

  • Refine by Keyword
  • 3 Software Product Lines
  • 2 Abstract interpretation
  • 2 Code mutations
  • 2 Data Management
  • 2 Decision tree lifted domain
  • Show More...

  • Refine by Type
  • 12 document

  • Refine by Publication Year
  • 6 2024
  • 2 2008
  • 2 2021
  • 1 2011
  • 1 2014

Questions / Remarks / Feedback
X

Feedback for Dagstuhl Publishing


Thanks for your feedback!

Feedback submitted

Could not send message

Please try again later or send an E-mail
© 2023-2024 Schloss Dagstuhl – LZI GmbH Imprint Privacy Contact