An algebra for feature-oriented software development

Feature-Oriented Software Development (FOSD) provides a multitude of formalisms, methods, languages, and tools for building variable, customizable, and extensible software. Along different lines of research different ideas of what a feature is have been developed. Although the existing approaches have similar goals, their representations and formalizations have not been integrated so far into a common framework. We present a feature algebra as a foundation of FOSD. The algebra captures the key ideas and provides a common ground for current and future research in this field, in which also alternative options can be explored

JPI Feature Models: Exploring a JPI and FOP Symbiosis for Software Modeling

Looking for a complete modular software development paradigm, this article presents Join Point Interface JPI Feature Models, in the context of a JPI and Feature-Oriented Programming FOP symbiosis paradigm. Therefore, this article describes pros and cons of JPI and FOP approaches for the modular software and software product line production, respective; and highlights the benefits of this mixing proposal; in particular, the JPI Feature Model benefits for a high-level software product line modeling. As an application example, this article applies JPI Features Models on a classic FOP example already modeled using a previous aspect-oriented feature model proposal. Main goals of this application are to visualize traditional feature models preserved components such alternative and optional feature sets and optional and mandatory features as well as special features associations (cross-tree constraints), and differences and advantages with respect to previous research works about extending feature model to support aspect-oriented modeling principles

The Feature-Architecture Mapping Method for Feature-Oriented Development of Software Product Lines

Software Produktlinien sind die Antwort von Software Engineering auf die zu-nehmende Komplexität und kürzerenProdukteinführungszeiten von heutigen Softwaresystemen. Nichtsdestotrotz erfordern Software Produktlinien einefortgeschrittene Wartbarkeit und hohe Flexibilität. Das kann durch die angemessene Trennung der Belange erreicht werden.Merkmale stellen die Hauptbelange im Kontext von Software Produktlinien dar. Demzufolge sollte ein Merkmal idealerweise ingenau einer Architekturkomponente implementiert werden. In der Praxis ist das jedoch nicht immer machbar. Deshalb solltezumindest ein starkes Mapping zwischen Merkmalen und der Architektur bestehen. Die Methoden zur Entwicklung von SoftwareProduktlinien, die dem Stand der Technik entsprechen, führen zu bedeutender Verstreutheit und Vermischung von Merkmalen. Indieser Arbeit wird die Feature-Architecture Mapping (FArM) Methode entwickelt, um ein stärkeres Mapping zwischen Merkmalenund der Produktlinien-Architektur zu erzielen. Der Input für FArM besteht in einem initialen Merkmalmodell, das anhand einerMethode zur Domänenanalyse erstellt wurde. Dieses initiale Merkmalmodell wird einer Serie von Transformationen unterzogen.Die Transformationen streben danach, ein Gleichgewicht zwischen der Sichtweise von Kunden und Softwarearchitekteneinzustellen. Die Merkmalinteraktionen werden während der Transformationen ausdrücklich optimiert. Von jedem Merkmal destransformierten Merkmalmodells wird eine Architekturkomponente abgeleitet. Die Architekturkomponenten implementieren dieApplikationslogik der entsprechenden Merkmale. Die Kommunikation zwischen den Komponenten spiegelt die Interaktion zwischenden Merkmalen wider. Dieser Ansatz führt im Vergleich zu den Produktlinien-Entwicklungsmethoden des Stands der Technik zueinem stärkeren Mapping zwischen Merkmalen und der Architektur und zu einer höheren Variabilität auf Merkmalebene. DieseEigenschaften haben eine bessere Wartbarkeit und eine vereinfachte generative Produktinstanzierung zur Folge, was wiederumdie Flexibilität der Produktlinien steigert. FArM wurde durch ihre Anwendung in einigen Domänen evaluiert, z.B. in denDomänen von Mobiltelefonen und Integrierten Entwicklungsumgebungen (IDEs). Diese Arbeit wird FArM anhand einer Fallstudie inder Domäne von Künstlichen Neuronalen Netzwerken präsentieren.Software product lines are the answer of software engineering to the increasing complexity and shorter time-to-market ofcontemporary software systems. Nonetheless, software product lines demand for advanced maintainability and high flexibility.The latter can be achieved through the proper separation of concerns. Features pose the main concerns in the context ofsoftware product lines. Consequently, one feature should ideally be implemented into exactly one architectural component. Inpractice, this is not always feasible. Therefore, at least a strong mapping between features and the architecture mustexist. The state of the art product line development methodologies introduce significant scattering and tangling offeatures. In this work, the Feature-Architecture Mapping (FArM) method is developed, to provide a stronger mapping betweenfeatures and the product line architecture. FArM receives as input an initial feature model created by a domain analysismethod. The initial feature model undergoes a series of transformations. The transformations strive to achieve a balancebetween the customer and architectural perspectives. Feature interaction is explicitly optimized during the feature modeltransformations. For each feature of the transformed feature model, one architectural component is derived. Thearchitectural components implement the application logic of the respective features. The component communication reflectsthe feature interaction. This approach, compared to the state of the art product line methodologies, allows a strongerfeature-architecture mapping and for higher variability on the feature level. These attributes provide highermaintainability and an improved generative approach to product instantiation, which in turn enhances product lineflexibility. FArM has been evaluated through its application in a number of domains, e.g in the mobile phone domain and theIntegrated Development Environment (IDE) domain. This work will present FArM on the basis of a case study in the domain ofartificial Neural Networks

Location-based variability for mobile information systems

Advances in size, power, and ubiquity of computing technology, sensors, and communication technology made possible the development of so-called mobile or nomadic information systems. A mobile information system has the potential to autonomously change its behaviour according to different location settings. Variability of location and system behaviour is a central feature of such new generation of information systems. This paper stresses the importance of modeling and analyzing variability of location as a basis for variability of software. We describe graphical and formal techniques to model location information, show their usage in conjunction with the goal-oriented framework i*/Tropos, and propose three analysis techniques on location-based goal models

Design and Development of Student Admission System in the State University of Jakarta

Student admission system is a must in every university, and so in the State University of Jakarta. Web applications are more widely used in the development of information systems because of the ease in distributing information to many users. By using the concept of re-used oriented, student admission system built in 2015 is developing by adding, editing, and deleting a requirement based on policy that enforce today. Moreover, adding web service as an intermediary between system and database as an extra feature in new system. The research was conducted using the Feature Driven Development (FDD) which is one of the Agile Method that does not have fixed rule in traceability model between requirement and feature, where this research went through several stages, namely needs to develop an overall model, build a feature list, plan by feature, design and build by feature. This study produces several products, there are Software Requirement Specification (SRS) and system that are built with React-Redux for its front-end and Laravel as its back-end.     Keywords: design and development, requirement, re-used oriented, feature driven development, web servic

Seamless Variability Management With the Virtual Platform

Customization is a general trend in software engineering, demanding systems that support variable stakeholder requirements. Two opposing strategies are commonly used to create variants: software clone & own and software configuration with an integrated platform. Organizations often start with the former, which is cheap, agile, and supports quick innovation, but does not scale. The latter scales by establishing an integrated platform that shares software assets between variants, but requires high up-front investments or risky migration processes. So, could we have a method that allows an easy transition or even combine the benefits of both strategies? We propose a method and tool that supports a truly incremental development of variant-rich systems, exploiting a spectrum between both opposing strategies. We design, formalize, and prototype the variability-management framework virtual platform. It bridges clone & own and platform-oriented development. Relying on programming-language-independent conceptual structures representing software assets, it offers operators for engineering and evolving a system, comprising: traditional, asset-oriented operators and novel, feature-oriented operators for incrementally adopting concepts of an integrated platform. The operators record meta-data that is exploited by other operators to support the transition. Among others, they eliminate expensive feature-location effort or the need to trace clones. Our evaluation simulates the evolution of a real-world, clone-based system, measuring its costs and benefits.Comment: 13 pages, 10 figures; accepted for publication at the 43rd International Conference on Software Engineering (ICSE 2021), main technical trac

Integrating the common variability language with multilanguage annotations for web engineering

Web applications development involves managing a high diversity of files and resources like code, pages or style sheets, implemented in different languages. To deal with the automatic generation of custom-made configurations of web applications, industry usually adopts annotation-based approaches even though the majority of studies encourage the use of composition-based approaches to implement Software Product Lines. Recent work tries to combine both approaches to get the complementary benefits. However, technological companies are reticent to adopt new development paradigms such as feature-oriented programming or aspect-oriented programming. Moreover, it is extremely difficult, or even impossible, to apply these programming models to web applications, mainly because of their multilingual nature, since their development involves multiple types of source code (Java, Groovy, JavaScript), templates (HTML, Markdown, XML), style sheet files (CSS and its variants, such as SCSS), and other files (JSON, YML, shell scripts). We propose to use the Common Variability Language as a composition-based approach and integrate annotations to manage fine grained variability of a Software Product Line for web applications. In this paper, we (i) show that existing composition and annotation-based approaches, including some well-known combinations, are not appropriate to model and implement the variability of web applications; and (ii) present a combined approach that effectively integrates annotations into a composition-based approach for web applications. We implement our approach and show its applicability with an industrial real-world system.Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech

Essays on exploitation and exploration in software development

Software development includes two types of activities: software improvement activities by correcting faults and software enhancement activities by adding new features. Based on organizational theory, we propose that these activities can be classified as implementation-oriented (exploitation) and innovation-oriented (exploration). In the context of open source software (OSS) development, developing a patch would be an example of an exploitation activity. Requesting a new software feature would be an example of an exploration activity. This dissertation consists of three essays which examine exploitation and exploration in software development. The first essay analyzes software patch development (exploitation) in the context of software vulnerabilities which could be exploited by hackers. There is a need for software vendors to make software patches available in a timely manner for vulnerabilities in their products. We develop a survival analysis model of the patch release behavior of software vendors based on a cost-based framework of software vendors. We test this model using a data set compiled from the National Vulnerability Database (NVD), United States Computer Emergency Readiness Team (US-CERT), and vendor web sites. Our results indicate that vulnerabilities with high confidentiality impact or high integrity impact are patched faster than vulnerabilities with high availability impact. Interesting differences in the patch release behavior of software vendors based on software type (new release vs. update) and type of vendor (open source vs. proprietary) are found. The second essay studies exploitation and exploration in the content of OSS development. We empirically examine the differences between exploitation (patch development) and exploration (feature request) networks of developers in OSS projects in terms of their social network structure, using a data set collected from the SourceForge database. We identify a new category of developers (ambidextrous developers) in OSS projects who contribute to patch development as well as feature request activities. Our results indicate that a patch development network has greater internal cohesion and network centrality than a feature request network. In contrast, a feature request network has greater external connectivity than a patch development network. The third essay explores ambidexterity and ambidextrous developers in the context of OSS project performance. Recent research on OSS development has studied the social network structure of software developers as a determinant of project success. However, this stream of research has focused on the project level, and has not recognized the fact that software projects could consist of different types of activities, each of which could require different types of expertise and network structures. We develop a theoretical construct for ambidexterity based on the concept of ambidextrous developers. We empirically illustrate the effects of ambidexterity and network characteristics on OSS project performance. Our results indicate that a moderate level of ambidexterity, external cohesion, and technological diversity are desirable for project success. Project success is also positively related to internal cohesion and network centrality. We illustrate the roles of ambidextrous developers on project performance and their differences compared to other developers

Exploring the Synergies between Join Point Interfaces and Feature-Oriented Programming

Feature-oriented programming FOP, and aspect-oriented programming AOP have been used to develop modular software product lines SPL. Both approaches focus on modularizing classes behavior and crosscutting concerns CC. Therefore, the symbiosis of FOP and AOP would permit reaching pros and cons of both software development approaches. Concretely, FOP permits a modular refinement of classes collaboration for software product lines SPL -an adequate structural representation of heterogeneous CC, but FOP does not well represent homogeneous CC. On the other hand, traditional AOP structurally well modularizes homogeneous CC, but aspects are not adequate to represent collaboration of classes for software evolution. In addition, AOP solutions present implicit dependencies and strong coupling between classes and aspects. Since Join Point Interface JPI solves mentioned AOP issues, this paper present JPI Feature Modules to represent and modularize the structure of FOP and JPI SPL instances, i.e., classes and join point interfaces for a transparent implementation in a FOP and JPI context. This paper, highlights benefits of a FOP and JPI symbiosis for the modular software conception using a case study to exemplify its use

Mixing of Join Point Interfaces and Feature-Oriented Programming for Modular Software Product Line

Feature-oriented programming (FOP) and aspect-oriented programming (AOP) focus on to modularize incremental classes behavior and crosscutting concerns, respectively, for software evolution. So, these software development approaches represent advanced paradigms for a modular software product lines production. Thereby, a FOP and AOP symbiosis would permit reaching pros and cons of both approaches. FOP permits a modular re nement of classes collaboration for software product lines (SPL), an adequate approach to represent named heterogeneous crosscutting concerns. FOP works on changes of di erent functionality pieces for which to de ne join points is not a simple task. Similarly, AOP structurally modularizes in a re ned manner homogeneous crosscutting concerns. Since traditional AOP like AspectJ presents implicit dependencies and strong coupling between classes and aspects, and the Join Point Interface JPI ap-proach solves these classic AOP issues, this article presents JPI Feature Modules for the FOP + JPI SPL components modularization, i.e., collaboration of classes, aspects, and join point interfaces along with their evolution, for a SPL transparent implementation in a FOP + JPI context. In addition, this article shows JPI Feature Modules of a case study to highlight mutual bene ts of FOP and JPI approaches for a modular SPL software conception