Sandro Schulze

Sandro Schulze

Auto-generated profile, based on publicly available information

Sandro Schulze

University of Magdeburg, Germany

Research Focus & Metrics

Academic Career Length

19Years (2008-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
27 May 2018
Verified
Conference Paper
Open access
PDF file
SKSebastian Krieter
Sebastian Krieter
TTThomas Thüm
Thomas Thüm
SSSandro Schulze
Sandro Schulze
RSReimar Schröter
Reimar Schröter
GSGunter Saake
Gunter Saake

1 December 2016
Verified
Conference Paper
Closed access
RLRemo Lachmann
Remo Lachmann
SSSandro Schulze
Sandro Schulze
MNManuel Nieke
Manuel Nieke
CSChristoph Seidl
Christoph Seidl
ISIna Schaefer
Ina Schaefer
Regression testing is the common task of retesting software that has been changed or extended (e.g., by new features) during software evolution. As retesting the whole program is not feasible with reasonable time and cost, usually only a subset of all test cases is executed for regression testing, e.g., by executing test cases according to test case prioritization. Although a vast amount of methods for test case prioritization exist, they mostly require access to source code (i.e., white-box). However, in industrial practice, system-level testing is an important task that usually grants no access to source code (i.e., black-box). Hence, for an effective regression testing process, other information has to be employed. In this paper, we introduce a novel technique for test case prioritization for manual system-level regression testing based on supervised machine learning. Our approach considers black-box meta-data, such as test case history, as well as natural language test case descriptions for prioritization. We use the machine learning algorithm SVM Rank to evaluate our approach by means of two subject systems and measure the prioritization quality. Our results imply that our technique improves the failure detection rate significantly compared to a random order. In addition, we are able to outperform a test case order given by a test expert. Moreover, using natural language descriptions improves the failure finding rate.

1 September 2015
Verified
Conference Paper
Closed access
SSStefan Stanciulescu
Stefan Stanciulescu
SSSandro Schulze
Sandro Schulze
AWAndrzej Wasowski
Andrzej Wasowski
Code cloning has been reported both on small (code fragments) and large (entire projects) scale. Cloning-in-the-large, or forking, is gaining ground as a reuse mechanism thanks to availability of better tools for maintaining forked project variants, hereunder distributed version control systems and interactive source management platforms such as Github. We study advantages and disadvantages of forking using the case of Marlin, an open source firmware for 3D printers. We find that many problems and advantages of cloning do translate to forking. Interestingly, the Marlin community uses both forking and integrated variability management (conditional compilation) to create variants and features. Thus, studying it increases our understanding of the choice between integrated and clone-based variant management. It also allows us to observe mechanisms governing source code maturation, in particular when, why and how feature implementations are migrated from forks to the main integrated platform. We believe that this understanding will ultimately help development of tools mixing clone-based and integrated variant management, combining the advantages of both.

1 February 2017
Verified
Conference Paper
Closed access
WFWolfram Fenske
Wolfram Fenske
JMJens Meinicke
Jens Meinicke
SSSandro Schulze
Sandro Schulze
SSSteffen Schulze
Steffen Schulze
GSGunter Saake
Gunter Saake
A common and simple way to create custom product variants is to copy and adapt existing software (a. k. a. the clone-and-own approach). Clone-and-own promises low initial costs for creating a new variant as existing code is easily reused. However, clone-and-own also comes with major drawbacks for maintenance and evolution since changes, such as bug fixes, need to be synchronized among several product variants. Software product lines (SPLs) provide solutions to these problems because commonalities are implemented only once. Thus, in an SPL, changes also need to be applied only once. Therefore, the migration of cloned product variants to an SPL would be beneficial. The main tasks of migration are the identification and extraction of commonalities from existing products. However, these tasks are challenging and currently not well-supported. In this paper, we propose a step-wise and semi-automated process to migrate cloned product variants to a feature-oriented SPL. Our process relies on clone detection to identify code that is common to multiple variants and novel, variant-preserving refactorings to extract such common code. We evaluated our approach on five cloned product variants, reducing code clones by 25 %. Moreover, we provide qualitative insights into possible limitations and potentials for removing even more redundant code. We argue that our approach can effectively decrease synchronization effort compared to clone-and-own development and thus reduce the long-term costs for maintenance and evolution.

25 January 2012
Verified
Conference Paper
Open access
SSSandro Schulze
Sandro Schulze
TTThomas Thüm
Thomas Thüm
MKMartin Kuhlemann
Martin Kuhlemann
GSGunter Saake
Gunter Saake
A software product line (SPL) is an advanced concept to manage a family of programs under one umbrella. As with stand-alone programs, maintenance is an important challenge within SPL engineering. One pivotal activity during software maintenance is refactoring; that is, restructuring a program's source code while preserving its external behavior. However, for SPLs, this definition is not sufficient because it does not take into account the behavior of a set of programs. In this paper, we focus on the specific requirements for applying refactorings in feature-oriented SPLs. We propose variant-preserving refactoring for such SPLs to ensure the validity of all SPL variants after refactoring. Furthermore, we present a first approach how the traditional refactoring definition can be extended so that it can be applied to SPLs based on feature-oriented programming. Finally, we state our experiences of applying such refactorings for the removal of code clones in feature-oriented SPLs and discuss the generalizability for other SPL implementation techniques.

23 September 2014
Verified
Conference Paper
Open access
PDF file
JKJonathan Koscielny
Jonathan Koscielny
SHSönke Holthusen
Sönke Holthusen
ISIna Schaefer
Ina Schaefer
SSSandro Schulze
Sandro Schulze
LBLorenzo Bettini
Lorenzo Bettini
FDFerruccio Damiani
Ferruccio Damiani