Browsing by Subject "Feature oriented programming"
Now showing 1 - 2 of 2
- Results Per Page
- Sort Options
Item Automatic software interface generation via feature oriented analysis(2004-08-16) Taylor, Ross Corey; Tesar, Delbert; Kapoor, ChetanSoftware interfaces are often defined as a layout of the controls for an application through which user interaction is performed. One of the fundamental concepts of this report requires a slightly different definition. A software interface is considered to be a well-defined algebraic specification of the inputs and outputs of a system. From this specification, interface representations can be generated that define the layout of the controls. With this view, a system has only one software interface but may have many distinct interface representations. This research builds on this concept to develop an approach to interface specification that allows algebraic reduction, optimization, and translation into desired representations. The approach is based on the software engineering concept of Feature Oriented Programming (FOP), which relies on composition of features to build software systems. This research defines software interfaces as features of a system in terms of properties and actions. Properties are attributes of the system that have a single known value at any time, which can be monitored or modified by the user. Actions are defined for each property as the means for monitoring and modifying the property. This report presents an approach to interface synthesis that relies on domain analysis, product-line analysis, interface generation, and interface translation. Domain analysis and product-line analysis are performed by a domain expert to specify the features of the domain in an Extended Backus-Naur Form (EBNF). An algebraic specification of the interface components, from which the interface to a particular product can be generated, is inferred from the EBNF specification. Interface generation involves feature composition, interface reduction, and interface optimization. These steps are defined based on the algebraic specification of the interface components and a supplementary specification of semantic relationships between properties and actions. Lastly, interface translation is performed to produce the desired interface representation from the interface specification for a product. The approach is demonstrated with a robotics domain example. The example covers a relatively complex system with thirteen properties, forty-two property values, and twenty-three actions that span system control, motion control, tool control, and various types of feedback. Also, twelve features were identified for the product family. Six of the features are composed to demonstrate interface generation and translation. The composition results in an interface represented by 49 algebraic statements with several redundancies. Interface reduction removes the redundancies and results in a syntactically complete interface with 28 algebraic statements (43% reduction). However, the effectiveness of the interface can be improved by applying semantic criteria to modify the syntax as is done during interface optimization. This semantics based optimization leads to a reduction of possible action combinations from 4096 to 1152. Lastly, interface translation is demonstrated via a sequential approach and a hierarchical approach. The first results in a C++ representation and the second results in a XML schema representation. Much of this work is conceptual, but the groundwork has been laid for future research into these areasItem Systematic techniques for efficiently checking Software Product Lines(2013-12) Kim, Chang Hwan Peter; Batory, Don S., 1953-; Khurshid, SarfrazA Software Product Line (SPL) is a family of related programs, which of each is defined by a combination of features. By developing related programs together, an SPL simultaneously reduces programming effort and satisfies multiple sets of requirements. Testing an SPL efficiently is challenging because a property must be checked for all the programs in the SPL, the number of which can be exponential in the number of features. In this dissertation, we present a suite of complementary static and dynamic techniques for efficient testing and runtime monitoring of SPLs, which can be divided into two categories. The first prunes programs, termed configurations, that are irrelevant to the property being tested. More specifically, for a given test, a static analysis identifies features that can influence the test outcome, so that the test needs to be run only on programs that include these features. A dynamic analysis counterpart also eliminates configurations that do not have to be tested, but does so by checking a simpler property and can be faster and more scalable. In addition, for runtime monitoring, a static analysis identifies configurations that can violate a safety property and only these configurations need to be monitored. When no configurations can be pruned, either by design of the test or due to ineffectiveness of program analyses, runtime similarity between configurations, arising due to design similarity between configurations of a product line, is exploited. In particular, shared execution runs all the configurations together, executing bytecode instructions common to the configurations just once. Deferred execution improves on shared execution by allowing multiple memory locations to be treated as a single memory location, which can increase the amount of sharing for object-oriented programs and for programs using arrays. The techniques have been evaluated and the results demonstrate that the techniques can be effective and can advance the idea that despite the feature combinatorics of an SPL, its structure can be exploited by automated analyses to make testing more efficient.