Abstract Context In recent years, the multi-class classification of non-functional requirements has seen improvements through the use of Machine Learning algorithms. However, challenges such as data scarcity and class imbalance persist, particularly for languages other than English, such as Spanish. Objective This study aims to analyze the performance metrics of Machine Learning algorithms for classifying non-functional requirements translated into and originally written in Spanish. It evaluates the effectiveness of dataset balancing techniques and conducts cross-dataset validation to assess the generalizability of the models. Method A dataset balancing process was conducted using a combination of oversampling and undersampling techniques. Six algorithms were trained in two experiments using a hyperparameter tuning process, employing two different datasets: PROMISE_exp_translated and the newly PROMISE_exp_balanced . The best-performing models were further tested on unseen data to evaluate their generalizability. Results Logistic Regression and Naive Bayes demonstrated superior performance on the translated dataset, achieving f1-scores of 82% and 81%, respectively. Although overall performance decreased on the balanced dataset, specific underrepresented classes such as Portability and Fault Tolerance benefited from the balancing process. Conclusion Shallow Machine Learning algorithms are effective for classifying Spanish non-functional requirements, particularly when addressing data imbalance. The study highlights the importance of dataset balancing in improving classification performance for specific classes and provides insights into the challenges of generalizing models across datasets.

Domain-specific languages (DSLs) are essential for modeling specialized concepts, offering greater fluency and efficiency than general-purpose languages. However, their adoption is often hindered by steep learning curves, limited tools, and complex implementations. While large language models (LLMs) can generate DSL code from natural language, their performance is limited in niche areas due to a lack of training on specific DSL definitions. This paper introduces DSL-Xpert 2.0, a tool that addresses these challenges by using LLMs to generate DSL code effortlessly. Integrating grammar prompting and few-shot learning ensures the effective handling of proprietary DSLs. In addition, advanced features such as automatic grammar validation, input/output correction, and integration with platforms like OpenAI, HuggingFace, and WebLLM provide robust, reliable results while simplifying workflows for novices and experts. To further demonstrate the tool’s practical value, this paper provides a running example illustrating its workflow and a complementary user survey conducted across multiple DSLs of varying complexity, following the Technology Acceptance Model (TAM), to evaluate its impact on easing the DSL learning curve. With a user-friendly and flexible design, DSL-Xpert 2.0 supports a wide range of DSL designs with minimal configuration. Its intuitive interface allows developers to focus on innovative problem-solving rather than technical complexities. Findings from the user survey confirm that DSL-Xpert 2.0 effectively reduces the learning effort required to work with DSLs and is perceived as both useful and easy to use. Additionally, this paper provides a detailed performance analysis across various LLMs, showcasing the adaptability and effectiveness of the tool. By simplifying DSL development and lowering entry barriers, DSL-Xpert 2.0 accelerates adoption and innovation, positioning itself as a valuable resource for domain-specific projects.

Many businesses depend on legacy systems, which often use outdated technology that complicates maintenance and updates. Therefore, software modernization is essential, particularly data migration between different database schemas. Established methodologies, like model transformation and ETL tools, facilitate this migration. However, these methodologies require deep knowledge of database languages and both the source and target schemas. This necessity renders data migration an error-prone and cognitively demanding task. Our objective is to alleviate developers’ workloads during schema evolution by proposing DAMI-Framework. This framework incorporates a domain-specific language (DSL) and a parser to facilitate data migration between database schemas. DAMI-DSL simplifies schema mapping, while the parser automates SQL script generation. To evaluate DAMI-Framework, we conducted an empirical evaluation with 21 developers to assess their experiences using our DSL versus traditional SQL. The study allows us to measure their perceptions of the DSL properties and user experience. The participants praised DAMI-DSL for its readability and ease of use. The findings indicate that our framework has positive impact in data migration efforts compared to SQL scripts, by reducing the lines of code and characters required for the migration by 18.3% and 35.6%, respectively.

Background: Ensemble models play an important role in integrating multiple classifiers in a wide range of applications, such as medical diagnosis, sentiment analysis, and financial market trends. In Requirements Engineering (RE), automatic requirements classification can be improved by the utilization of these models. Aims: This paper analyses the performance metrics of voting and stacking ensemble models for requirements classification prediction. Moreover, a cross-dataset validation was performed for the meta-models generated using the stacking ensemble method. Methods: Some previously trained base models and two datasets of software requirements written in Spanish (translated PROMISE_exp and ReSpa dataset) were used to build the ensemble models. Results: The results indicate that the stacking model achieved a weighted F1-score of 0.828 using Support Vector Machine (SVM) and Multi-layer Perceptron (MLP) for translated PROMISE_exp dataset. For the ReSpa dataset, the stacking model achieved a weighted F1-score of 0.890 using Logistic Regression (LR). Conclusion: This study confirms a slight improvement in the performance of binary requirements classification using stacking ensemble methods over voting and most individual base models. Moreover, combining all models outperforms combinations that include only Shallow ML or DL models.

Software Product Lines (SPL) enable the creation of software product families with shared core components using feature models to model variability. Choosing features from a feature model to generate a product may not be sufficient in certain situations because the application engineer may need to be able to decide on configuration time the system’s elements to which a certain feature will be applied. Therefore, there is a need to select which features have to be included in the product but also to which of its elements they have to be applied. We introduce local features that are selectively applied to specific parts of the system during product configuration. We formalize local features using multimodels to establish relationships between local features and other elements of the system models. The paper includes examples illustrating the motivation for local features, a formal definition, and a domain-specific language for specification and implementation. Finally, we present a case study in a real scenario that shows how the concept of local features allowed us to define the variability of a complex system. The examples and the application case show that the proposal achieves higher customization levels at the application engineering phase.

In recent years, mainly due to the application of smartphones in this area, research in human activity recognition (HAR) has shown a continuous and steady growth. Thanks to its wide range of sensors, its size, its ease of use, its low price and its applicability in many other fields, it is a highly attractive option for researchers. However, the vast majority of studies carried out so far focus on laboratory settings, outside of a real-life environment. In this work, unlike in other papers, progress was sought on the latter point. To do so, a dataset already published for this purpose was used. This dataset was collected using the sensors of the smartphones of different individuals in their daily life, with almost total freedom. To exploit these data, numerous experiments were carried out with various machine learning techniques and each of them with different hyperparameters. These experiments proved that, in this case, tree-based models, such as Random Forest, outperform the rest. The final result shows an enormous improvement in the accuracy of the best model found to date for this purpose, from 74.39% to 92.97%.

Machine Learning (ML) algorithms have become a powerful instrument in software requirements classification. Nevertheless, most of the research focusing on requirements is in English, with less attention to other languages. Given a lack of datasets in Spanish, we created a new dataset from a collection of requirements from final degree projects from the University of A Coruña. In this paper, we investigate which combinations of text vectorization techniques with ML algorithms perform best for requirements classification in a Spanish dataset. We found that SVM with TF-IDF gives the highest f1-score (0.95 and 0.79 for functional and non-functional classification).

Web engineering involves managing a high diversity of artifacts implemented in different languages and with different levels of granularity. Technological companies usually implement variable artifacts of Software Product Lines (SPLs) using annotations, being reluctant to adopt hybrid, often complex, approaches combining composition and annotations despite their benefits. This paper proposes a combined approach to support fine and coarse-grained variability for web artifacts. The proposal allows web developers to continue using annotations to handle fine-grained variability for those artifacts whose variability is very difficult to implement with a composition-based approach, but obtaining the advantages of the composition-based approach for the coarse-grained variable artifacts. A combined approach based on feature modeling that integrates annotations into a generic composition-based approach. We propose the definition of compositional and annotative variation points with custom-defined semantics, which is resolved by a scaffolding-based derivation engine. The approach is evaluated on a real-world web-based SPL by applying a set of variability metrics, as well as discussing its quality criteria in comparison with annotations, compositional, and combined existing approaches. Our approach effectively handles both fine and coarse-grained variability. The mapping between the feature model and the web artifacts promotes the traceability of the features and the uniformity of the variation points regardless of the granularity of the web artifacts. Using well-known techniques of SPLs from an architectural point of view, such as feature modeling, can improve the design and maintenance of variable web artifacts without the need of introducing complex approaches for implementing the underlying variability.

Abstract Even though different applications based on Geographic Information Systems (GIS) provide different features and functions, they all share a set of common concepts (e.g., spatial data types, operations, services), a common architecture, and a common set of technologies. Furthermore, common structures appear repeatedly in different GIS, although they have to be specialized in specific application domains. Multilevel modeling is an approach to model-driven engineering (MDE) in which the number of metamodel levels is not fixed. This approach aims at solving the limitations of a two-level metamodeling approach, which forces the designer to include all the metamodel elements at the same level. In this paper, we address the application of multilevel modeling to the domain of GIS, and we evaluate its potential benefits. Although we do not present a complete set of models, we present four representative scenarios supported by example models. One of them is based on the standards defined by ISO TC/211 and the Open Geospatial Consortium. The other three are based on the EU INSPIRE Directive (territory administration, spatial networks, and facility management). These scenarios show that multilevel modeling can provide more benefits to GIS modeling than a two-level metamodeling approach.

Digital Libraries have become popular nowadays since important libraries all over the world started distributing their collections online, properly classified, and, in many cases, with access to the digital version of the resource. These programs have been beneficial to the general population as well as research groups in fields such as language and literature. Nonetheless, since their creation is a time-consuming and costly process, small organizations are forced to rely on obsolete or poorly designed software. However, most of the features, including the data model, are shared by this type of system, with minor variations depending on the type of resources to be handled. This article presents a Software Product Line (SPL) for the semi-automatic generation of Digital Libraries (DL). Our SPL allows developers to specify which DL features are required, which will define the data model variationand the generated source code. The specification is then transformed into a fully functional DL application with the specified features that is ready for deployment. We present the feature model, the SPL implementation, and acase study on three sample projects that enabled us to evaluate the resulting software, with a focus on development effort savings.

In this paper, we present a declarative domain-specific language (DSL) for the development of Geographic Information Systems (GIS). GIS applications manage information with a spatial component, usually in the form of points, lines, polygons, or variants of these basic data types, in domains where the spatial information plays a central role. They provide the user with different functionalities on different application domains, but they are usually developed according to a common architecture and using a common set of technologies. Hence, they share a significant number of elements that make some aspects of their development quite repetitive. Our DSL allows developers to specify the entities, geographic layers, and maps of the applications using a declarative language. Then, the specification is transformed into a working GIS application. We present the language, its implementation, and a case study on two sample projects that allowed us to evaluate the resulting software, paying special attention to the savings in the development effort.

Background: A software sustainability model is commonly defined in terms of social, economic, technical and environmental dimensions. A key challenge is its characterization regarding sustainability requirements and their dependencies since it depends on, and varies with, the type of software system, and changes in operational contexts. Aims: With the purpose of facilitating the definition of a context-dependent software sustainability model, we introduce nichesourcing as a type of distributed problem-solving paradigm, named crowdsourcing. Method: First a set of nichesourcing requirements were identified, and an existing nichesourcing methodology, originally used in the cultural heritage domain was analyzed with respect to its applicability in Software Engineering. Results: As a result, we propose an adapted methodology for nichesourcing the knowledge on sustainability requirements and their dependencies. Strengths and challenges for crowdsourced software engineering are also identified.

Geographic information systems (GIS) manage entities with a spatial component (typically, in the form of a point, line, or polygon defined according to a known geographic coordinate system), and provide specific operations to process them, and specific interfaces to visualize them. Although different GIS may provide a completely different set of functionalities, they all share a common set of concepts, architecture, and technologies. Therefore, in the development of GIS there are typically large parts of the system that can be very repetitive. In this paper, we present a domain-specific language to develop GIS from high-level declarative specifications. We present a metamodel for web-based GIS, and a domain-specific language based on that metamodel. We also present a usage example that shows how the language would be used in a real scenario.

Distributing software as a service (SaaS) has become a major trend for web-based systems.However, this software distribution model poses many challenges.One of them is feature variability, that is, some features of the system may be required by some users, but not by all of them.In addition, variability is more complex than just including or excluding a feature, since different types of relationships may exist between features.The implementation of this variability, and the parametrization and configuration of the system can be complex in this context, so the development process of a SaaS system must adequately address variability management.In this paper we present an

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.

Even though the field of spatial databases is more than 40 years old, most existing logical data models are highly focused either on spatial objects (vector data models) or spatial fields (raster data models). Furthermore, spatial index structures and query algorithms are still proposed for one of the approaches and little research work has been dedicated to index structures and query algorithms where both types of information are needed. However, due to the current high availability of different types of data, it is much more common nowadays that applications require querying vector and raster data at the same time. This paper presents a method to perform a spatial query between a vector data set represented using an R-tree and a raster data set represented using a compact and space-efficient data structure called k2-tree that saves main memory space. Therefore, the method described in this paper solves two problems: first, it can be used to evaluate queries between vector and raster data without having to convert one of the data sets to the other data model; and second, it saves main memory space, thus obtaining a more scalable system.

An inconsistency measure can be used to compare the quality of different data sets and to quantify the cost of data cleaning. In traditional relational databases, inconsistency is defined in terms of constraints that use comparison operators between attributes. Inconsistency measures for traditional databases cannot be applied to spatial data sets because spatial objects are complex and the constraints are typically defined using spatial relations. This paper proposes an inconsistency measure to evaluate how dirty a spatial data set is with respect to a set of integrity constraints that define the topological relations that should hold between objects in the data set. The paper starts by reviewing different approaches to quantify the degree of inconsistency and showing that they are not suitable for the problem. Then, the inconsistency measure of a data set is defined in terms of the degree in which each spatial object in the data set violates topological constraints, and the possible representations of spatial objects are points, curves, and surfaces. Finally, an experimental evaluation demonstrates the applicability of the proposed inconsistency measure and compares it with previously existing approaches.

The high bandwidth requirements of GIS data is usually one of the main bottlenecks in the development of client-server GIS applications. Nowadays, spatial information is generated with high resolution and thus it has high storage costs. Depending on the specific use case, the precision at which that spatial information is needed is significantly smaller, so reducing its precision (within a given margin of error) is a straightforward approach to reducing transmission costs. The main technique to reduce precision in vectorial spatial representations is geometry simplification [1]. Additionally, data compression techniques are usually applied in the communication layer to further reduce data transmission costs. In this work, we show that the compressibility properties of the data should be taken into account when applying geometry simplification techniques. We present a naive two-stage approach that first applies geometry simplification using at most the 93% of the margin of error, and then applies coordinate approximation using the remaining 7%. Our approach leads to obtaining around 30-40% better compression with general-purpose compressors on the transformed data than when only simplification is performed.

The fact that abstract spatial data models have to be implemented in computers with finite resources causes many problems to developers of spatial databases, because the discrete and physical models proposed break the properties of the operations defined at the abstract level. Several approaches have been proposed, but their weaknesses prevent their adoption. In this paper, we present a revision of Dualgrid designed to be used with models based on floating point coordinates. It succeeds in keeping the properties of the abstract spatial data models while using a floating point coordinate representation that does not degrade the performance and storage requirements of the implementation.

In contrast to the enormous development of database management systems to support spatial databases, very little work has been done in evaluating the quality of spatial data in terms of how much they satisfy a set of topo-semantic integrity constraints, in particular, a set of topological dependency constraints. In the same way, mechanisms for enforcing the satisfaction of those constraints are not necessarily available or even feasible. In this paper we propose measures to evaluate the degree of violation of a topological dependency constraint by geometries stored in a spatial database instance. We also propose how these measures can be aggregated to globally evaluate the data quality of a database instance such that they enable to compare database instances in terms of their constraint satisfaction. We provide an experimental evaluation of those measures using synthetic and real data. We validate our measures by i) analyzing their correlation with the semantic distance of topological relations and ii) checking that the more we randomly modify geometries to make database instances inconsistent, the more our global data quality measure decreases, showing its sensibility to the introduced constraint violations.

Abstract In this paper we present our experience in the development of a geographic information system that includes a large database (over 7 GB) with information about the infrastructure and facilities of the municipalities in the province of A Coruña (northwestern Spain). Three interesting aspects of the whole project are described in some detail due to their intrinsic interest for the development of this kind of system. These aspects are: (1) the design of the data model and the system architecture, which is oriented to support some advanced features such as multiscale active maps; (2) the problem of designing appropriate workflows to populate the database; and (3) the design of a Web‐based application to exploit the geographic database through a user‐friendly interface. Copyright © 2007 John Wiley & Sons, Ltd.

In implementations of non-standard database systems, large objects are often embedded within an aggregate of different types, i.e. a tuple. For a given size and access probability of a large object, query performance depends on its representation: either inlined within the aggregate or swapped out to a separate object. Furthermore, the implementation of complex data models often requires nested large objects, and access performance is highly influenced by the clustering strategy followed to store the resulting tree of large objects. In this paper we describe a large object extension which automatically clusters nested large objects. A rank function is developed which indicates the suitability of a large object being inserted into a given cluster. We present two clustering algorithms of different run-time complexity, both using the rank function, and a series of simulations is performed to compare them to each other as well as to two trivial ones. One of the algorithms proves to compute the most efficient clustering in all tests.