A5033605569- Advanced Software Engineering Methodologies
- Software Engineering Research
- Model-Driven Software Engineering Techniques
- Service-Oriented Architecture and Web Services
- Advanced Database Systems and Queries
- Software System Performance and Reliability
- Logic, programming, and type systems
- Software Testing and Debugging Techniques
- Distributed systems and fault tolerance
- Distributed and Parallel Computing Systems
- Data Management and Algorithms
- Software Reliability and Analysis Research
- Parallel Computing and Optimization Techniques
- Formal Methods in Verification
- Real-Time Systems Scheduling
- Advanced Data Storage Technologies
- Semantic Web and Ontologies
- Scientific Computing and Data Management
- Embedded Systems Design Techniques
- Cloud Computing and Resource Management
- Software Engineering Techniques and Practices
- Business Process Modeling and Analysis
- Data Mining Algorithms and Applications
- Manufacturing Process and Optimization
- Advanced Computational Techniques and Applications
The University of Texas at Austin
2014-2023
Karlsruhe University of Education
2002
Cornell University
2002
Utrecht University
2002
Newcastle University
2002
Heidelberg (Poland)
2002
University of Arizona
1994
Florida International University
1990
Institut national de recherche en informatique et en automatique
1989
University of Toronto
1979-1982
Step-wise refinement is a powerful paradigm for developing complex program from simple by adding features incrementally. We present the AHEAD (algebraic hierarchical equations application design) model that shows how step-wise scales to synthesize multiple programs and noncode representations. software can have an elegant, mathematical structure expressible as nested sets of equations. review tool set supports AHEAD. As demonstration its viability, we bootstrapped tools equational...
We present a domain-independent model of hierarchical software system design and construction that is based on interchangeable components large-scale reuse. The unifies the conceptualizations two independent projects, Genesis Avoca, are successful examples component/building-block technologies domain modeling. Building-block exploit reuse, rely open architecture software, elevate granularity programming to subsystem level. Domain modeling formalizes similarities differences among systems...
Features express the variabilities and commonalities among programs in a software product line (SPL). A feature model defines valid combinations of features, where each combination corresponds to program an SPL. SPLs their models evolve over time. We classify evolution via modifications as refactorings, specializations, generalizations, or arbitrary edits. present algorithm reason about edits help designers determine how membership SPL has changed. Our takes two input (before after edit...
A "refinement" is a functionality addition to software project that can affect multiple dispersed implementation entities (functions, classes, etc.). In this paper, we examine large-scale refinements in terms of fundamental object-oriented technique called collaboration-based design. We explain how collaborations be expressed existing programming languages or supported with new language constructs (which have implemented as extensions the Java language). present specific expression mixin...
VLSI CAD applications deal with design objects that have an interface description and implementation description. Versions of a common but differ in their implementations. A molecular object is modeling construct which enables database entity to be represented by two sets heterogeneous records, one set describes the object's other its implementation. Thus reasonable starting point for begin concept objects. In this paper, we identify concepts are fundamental capturing semantics versions...
Feature oriented refactoring (FOR) is the process of decomposinga program into features, where a feature an increment in programfunctionality. We develop theory FOR that relates code refac-toring to algebraic factoring. Our explains relationshipsbetween features and their implementing modules, why fea-tures different programs product-line can have differentimplementations. describe tool methodologybased on our theory, present validating case study.
Programs of a software product line can be synthesized by composing modules that implement features. Besides high-level domain constraints govern the compatibility features, there are also low-level implementation constraints: feature module reference elements defined in other modules. Safe composition is guarantee all programs type safe: i.e., absent references to undefined (such as classes, methods, and variables). We show how safe properties verified for AHEAD lines using models SAT solvers.
article Share on Automated analysis of feature models: challenges ahead Authors: Don Batory University Texas at Austin AustinView Profile , David Benavides Seville, Spain SpainView Antonio Ruiz-Cortes Authors Info & Claims Communications the ACMVolume 49Issue 12December 2006 pp 45–47https://doi.org/10.1145/1183236.1183264Published:01 December 2006Publication History 121citation1,966DownloadsMetricsTotal Citations121Total Downloads1,966Last 12 Months63Last 6 weeks1 Get Citation AlertsNew...
The Jakarta Tool Suite (JTS) aims to reduce substantially the cost of generator development by providing domain-independent tools for creating domain-specific languages and component-based generators called GenVoca generators. JTS is a set precompiler-compiler extending industrial programming (e.g., Java) with constructs. itself where precompilers JTS-extended are constructed from components.
Software product lines aim to create highly configurable programs from a set of features. Common belief and recent studies suggest that aspects are well-suited for implementing We evaluate the suitability AspectJ with respect this task by case study refactors embedded database system Berkeley DB into 38 Contrary our initial expectations, results were not encouraging. As number in feature grows, there is noticeable decrease code readability maintainability. Most unique powerful features...
Customizable programs and program families provide user-selectable features to allow users tailor a an application scenario. Knowing in advance which feature selection yields the best performance is difficult because direct measurement of all possible combinations infeasible. Our work aims at predicting based on selected features. However, when interact, accurate predictions are challenging. An interaction occurs particular combination has unexpected influence performance. We present method...
Customizable programs and program families provide user-selectable features to allow users tailor a an application scenario. Knowing in advance which feature selection yields the best performance is difficult because direct measurement of all possible combinations infeasible. Our work aims at predicting based on selected features. However, when interact, accurate predictions are challenging. An interaction occurs particular combination has unexpected influence performance. We present method...
A Software Product Line (SPL) is a family of programs where each program defined by unique combination features. Testing or checking properties an SPL hard as it may require the examination combinatorial number programs. In reality, however, features are often irrelevant for given test - they augment, but do not change, existing behavior, making many feature combinations unnecessary far testing concerned. this paper we show how to reduce amount effort in SPL. We represent form conventional...
Software Product Lines (SPLs) are highly configurable systems. This raises the challenge to find optimal performing configurations for an anticipated workload. As SPL configuration spaces huge, it is infeasible benchmark all one. Prior work focused on building performance models predict and optimize configurations. Instead, we randomly sample recursively search a space directly near-optimal without constructing prediction model. Our algorithms simpler have higher accuracy efficiency.
GenVoca generators synthesize software systems by composing components from reuse libraries. are designed to export and import standardized interfaces, thus be plug-compatible, interchangeable, interoperable with other components. We examine two different but important issues in system synthesis. First, not all syntactically correct compositions of semantically correct. present simple, efficient, domain-independent algorithms for validating Second, that immutable interfaces too restrictive...
Step-wise refinement is a powerful paradigm for developing complex program from simple by adding features incrementally. We present the AHEAD (Algebraic Hierarchical Equations Application Design) model that shows how step-wise scales to synthesize multiple programs and non-code representations. software can have an elegant, hierarchical mathematical structure expressible as nested sets of equations. review tool set supports AHEAD. As demonstration its viability, we bootstrapped tools solely...
article Free Access Share on TSQL2 language specification Authors: Richard Thomas Snodgrass View Profile , Ilsoo Ahn Gadi Ariav Don Batory James Clifford Curtis E. Dyreson Ramez Elmasri Fabio Grandi Christian S. Jensen Wolfgang Käfer Nick Kline Krishna Kulkarni T. Y. Cliff Leung Nikos Lorentzos John F. Roddick Arie Segev Michael D. Soo Suryanarayana M. Sripada Authors Info & Claims ACM SIGMOD RecordVolume 23Issue 1March 1994 pp 65–86https://doi.org/10.1145/181550.181562Online:01 March...
Feature oriented programming (FOP) is an emerging paradigm for application synthesis, analysis, and optimization. A target specified declaratively as a set of features, like many consumer products (e.g., personal computers, automobiles). FOP technology translates such declarative specifications into efficient programs.