M.Sc Sagar Sunkle

No.

Publications

Year

Referreed

1.

Sebastian Günther and Sagar Sunkle. Feature-oriented programming with Ruby. Science of Computer Programming, Elsevier—Special Issue on Feature-Oriented Software Development, 2011. To appear.

PhD -2010

2.

Sagar Sunkle and Mario Pukall. Using Reified Contextual Information for Safe Run-time Adaptation of Software Product Lines. In Proceedings of the 7th ECOOP Workshop on Reflection, AOP and Meta-Data for Software Evolution, June 2010.

Software product lines (SPLs) is a paradigm to implement software products based on features. Contemporary SPL implementation techniques provide support for compile-time composition of features. Many approaches have been suggested for run-time adaptation of product lines which do not consider safe composition properties. This paper presents FeatureJ which enables safe compile-time and run-time composition of multiple product lines. We identify four compilation techniques necessary to achieve safe run-time adaptation of product lines in FeatureJ: a) type checking of feature modules, b) availability of contextual information at run-time, c) resolving class-loading issues for multiple updated variants, and d) an application container for executing and updating multiple variants. Accordingly, we show how an existing approach can be integrated with FeatureJ to support safe run-time adaptation.

In ACM

3.

Sagar Sunkle. Assessing Modularity of Feature Concern. In Proceedings of 4th Workshop on Assessment of Contemporary Modularization Techniques (ACOM) at SPLC, 2010. Short Paper

In this paper, we put forth five observations regarding the implementation of feature concern using contemporary modularity mechanisms. Based on these observations, we propose a concern-centric approach for the assessment of feature modularity that uses syntactic and semantic reduction functions that separate the feature concern from variants containing it. We propose how the modularity of separated feature concern may be assessed using such functions.

In Web

4.

Sebastian Günther and Sagar Sunkle. Dynamically Adaptable Software Product Lines Using Ruby Metaprogramming. In Proceedings of International Workshop on Feature-oriented Software Development (FOSD), 2010.

Software product lines (SPLs) is a paradigm to structure software development assets in a common and reusable form. Out of this common asset base, which includes the application's source code, concrete product variants can be created. The variants are differing in terms of the features, which are basically an increment in functionality important for a stakeholder. Feature-oriented programming (FOP) provides the capability to compose those different variants. In earlier work we presented rbFeatures, a FOP implementation in Ruby. With rbFeatures, developers add disciplined annotation to the source code to capture code belonging to a feature. Thereby, the features are provided as first-class entities of the application. This paper presents an extension to rbFeatures that brings SPLs and their variants as first-class entities too. The entities allow powerful runtime-adaptation and configuration, like to add new features or constraints to the SPL and the instantiate several variants with different feature configurations. The particular contribution is to show how Ruby's metaprogramming capabilities are used to design first-class entities, and explain the usage of our approach with a common case study.

In ACM

5.

Sebastian Günther and Sagar Sunkle. Enabling Feature-Oriented Programming in Ruby. Technical Report 16, Very Large Business Application Lab, University of Magdeburg, Magdeburg, Germany, November 2009.

Feature-oriented programming (FOP), captures requirements and functionality of software at a higher level of abstraction. Modular software can be built using features which are both conceptual entities in the analysis phase and concrete entities in the design and implementation phases of software development. Most research in FOP addresses static languages like Java and C++. In this paper, we describe FOP in the context of the dynamic programming language Ruby. Ruby is a dynamic language featuring a fully object-oriented implementation and rich meta-programming facilities. Developers can manipulate the program behavior to a large extent, which gives flexibility in designing software. In order to implement features, three programming mechanisms can be identified: Basic expressions (object-oriented mechanisms), meta-programming and reflection (run-time modifications of variables and methods), and holistic manipulations (treating the program as a string). We discuss and compare these mechanisms for their ability to satisfy the four central feature properties namely, naming, identification, expressing, and composition. Furthermore, we sketch two implementations of FOP in Ruby. The first implementation uses annotations in the form of comments to express feature-related code. The second implementation one is a DSL which adds features as types to the Ruby language.

PhD -2009

6.

Sagar Sunkle, Sebastian Günther, and Gunter Saake. Representing and Composing First-class Features with FeatureJ. Technical Report 17, Department of Computer Science, Otto-von-Guericke University of Magdeburg, Magdeburg, Germany, November 2009.

Software product lines (SPLs) enable creating product families, set of products that differ in terms of features. Traditionally, techniques for implementing features have sided with one of the two views of features: as distinguishable characteristics or as increments/changes in program functionality of the software under consideration. We argue that in order to realize the full potential of features as a separation of concerns mechanism or a modularity mechanism in its own right, both of these views must be supported by the representation of features. Furthermore, the composition of such uniformly represented features should be streamlined so that both can evolve together. Towards this end, we present FeatureJ, an implementation technique that integrates features, variants, and product lines as first-class entities, namely types, in the Java programming language. We review the trends in the representation and composition of features in the current implementation techniques and arrive at a set of requirements to represent features as first-class entities. We demonstrate the syntax of FeatureJ and explain its compiler architecture with a running example of a product line. We compare our implementation approach with other approaches in terms of the representation and composition of features and state the advantages that our approach brings to the implementation of SPLs.

7.

Marko Rosenmüller, Christian Kästner, Norbert Siegmund, Sagar Sunkle, Sven Apel, Thomas Leich, and Gunter Saake. SQL à la Carte – Toward Tailor-made Data Management. In Datenbanksysteme in Business, Technologie und Web (BTW), pages 117–136, March 2009.

The size of the structured query language (SQL) continuously increases. Extensions of SQL for special domains like stream processing or sensor networks come with own extensions, more or less unrelated to the standard. In general, underlying DBMS support only a subset of SQL plus vendor specific extensions. In this paper, we analyze application domains where special SQL dialects are needed or are already in use. We show how SQL can be decomposed to create an extensible family of SQL dialects. Concrete dialects, e.g., a dialect for web databases, can be generated from such a family by choosing SQL features à la carte. A family of SQL dialects simplifies analysis of the standard when deriving a concrete dialect, makes it easy to understand parts of the standard, and eases extension for new application domains. It is also the starting point for developing tailor-made data management solutions that support only a subset of SQL. We outline how such customizable DBMS can be developed and what benefits, e.g., improved maintainability and performance, we can expect from this.

In DBLP

8.

Syed Saif ur Rahman, Marko Rosenmüller, Norbert Siegmund,  Sagar Sunkle, Gunter Saake and Sven Apel. Data Management for Embedded Systems: A Cell-based Approach In DEXA'2009 Workshop on Embedded Data-Centric Systems (EDACS). IEEE Computer Society, Sept. 2009.

Existing data management systems are very complex and provide a multitude of functionalities. Due to complexity and their monolithic architecture, these data management systems are not suitable for data-centric embedded systems. In order to cope with complexity of data management in such systems, we propose a novel approach to DBMS architecture, called Cellular DBMS, that is inspired by biological systems. Cellular DBMS is composed of multiple customizable embedded database instances, called Cells.We

illustrate how multiple atomic cells can be used together to provide scalable, resource efficient data management for embedded systems.

In Web

9.

Sebastian Günther and Sagar Sunkle. Feature-oriented programming with Ruby. In FOSD '09: Proceedings of the First International Workshop on Feature-Oriented Software Development, pages 11–18, New York, NY, USA, 2009. ACM.

Features identify core characteristics of software in order to produce families of programs. Through configuration, different versions of a program can be composed. Our approach is to design features as first-class entities of a language. With this approach, features can be constructed and returned by methods, stored in variables and used in many expressions of the language. This paper introduces rbFeatures, an implementation of first-class features in the dynamic programming language Ruby. Our goal is to show how such a language extension works with respect to its dynamic host language and the applicability of our results. In particular, we present a step-by-step walk-through how to use rbFeatures in order to implement known case-studies like the Expression Product Line and the Graph Product Line. Since we created a pure Ruby language extension, rbFeatures can be used with any existing programs and in any virtual machine implementing Ruby.

In ACM

10.

Sagar Sunkle, Marko Rosenmüller, Norbert Siegmund, Syed Saif ur Rahman, Gunter Saake, and Sven Apel.

Features as First-class Entities : Toward a Better Representation of Features. In Workshop on Modularization, Composition, and Generative Techniques for Product Line Engineering, number MIP-0802, pages 27–34. Department of Informatics and Mathematics, University of Passau, October 2008.

Features are distinguishable characteristics of a system relevant to some stakeholder. A product line is a set of products that differ in terms of features. Features do not have first-class status in contemporary programming languages. We argue that various problems related to features are a result of this abstraction and representation mismatch and that features should be elevated to a first-class status. We propose an extension to Java that implements features as first-class entities. We give examples of the syntax and semantics of this extension and explain how the new representation can handle features better.

In Web

PhD -2008

11.

Sagar Sunkle, Martin Kuhlemann, Norbert Siegmund, Marko Rosenmüller, and Gunter Saake. Generating Highly Customizable SQL Parsers. In Workshop on Software Engineering for Tailor-made Data Management, pages 29–34, March 2008.

Database technology and the Structured Query Language (SQL) have grown enormously in recent years. Applications from different domains have different requirements for using database technology and SQL. The major problem of current standards of SQL is complexity and unmanageability. In this paper we present an approach based on software product line engineering which can be used to create customizable SQL parsers and consequently different SQL dialects. We give an overview of how SQL can be decomposed in terms of features and how different features can be composed to create tailor-made parsers for SQL.

In ACM

1.

Non-Referreed

Sagar Sunkle. Feature-Oriented Decomposition of SQL:2003. Master‘s thesis, University of Magdeburg, Germany, October 2007.

In this thesis we explain how features and feature modeling form the analysis phase of Software Product Line Engineering and show that SQL:2003 can be decomposed on the basis of feature concept. Specifically, we -

Decompose SQL:2003 into features using various SQL:2003 ISO/ANSI standards and present these features in terms of feature diagrams.

Present an example of how to construct sub-grammars of SQL:2003 based on decomposed features and show how to compose them to obtain customized parsability for SQL:2003.

Review related feature implementation models and compare         them within the context of SQL:2003 features.

Master DKE - 2007

2.

Sagar Sunkle, Dietmar Rösner, and Manuela Kunze. Coreference in UIMA. Labor Praktikum, 2007. Labor Praktikum.

We extend IBM's UIMA (Unstructured Information Management Architecture), which is an open, industrial-strength, scalable and extensible platform for creating, integrating, and deploying unstructured information management solutions from combinations of semantic analysis and search components, with OpenNLP coreference component.

Master DKE - 2007

No.

Presentation

Year

1.

EDBT Workshop at Nantes, France -  Generating Highly Customizable SQL Parsers

2008

2.

Dagstuhl Seminar – 08281: software engineering for tailor-made data management / S. Apel, D. Batory, G. Graefe, G. Saake, and O. Spinczyk - Feature-oriented Query Processing

3.

RAM’SE Workshop at Maribor, Slovenia - Using Reified Contextual Information for Safe Run-time Adaptation of Software Product Lines

2010