<?xml version="1.0" encoding="UTF-8"?>
<rss xmlns:dc="http://purl.org/dc/elements/1.1/" version="2.0">
<channel>
<title>Vol. 8, no. 03 | Simposio Argentino de Ingeniería de Software (ASSE 2022)</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151576</link>
<description/>
<pubDate>Tue, 17 Nov 2026 04:02:40 GMT</pubDate>
<dc:date>2026-11-17T04:02:40Z</dc:date>
<item>
<title>Composition rules for aspect-oriented process models with BPMN 2.0</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151650</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
The aspect-oriented paradigm poses a solution based on the separation of crosscutting concerns to the problems of scattering and tangling present in the code written with traditional approaches, including object-oriented programming. However, this solution can also be applied at all abstraction levels of the software development life cycle, including the business modeling phase. In this paper, a consistent set of rules for the composition of concerns for the business model is presented. These rules, designed using the BPMN 2.0 standard, seeks to ensure the correct composition of diagrams, preserving the syntax of the standard notation, to substantially improve the semantic integrity of the whole model and, consequently, to reduce the appearance of conflicts that normally arise when crosscutting concerns are composed at the join points
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151650</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>The aspect-oriented paradigm poses a solution based on the separation of crosscutting concerns to the problems of scattering and tangling present in the code written with traditional approaches, including object-oriented programming. However, this solution can also be applied at all abstraction levels of the software development life cycle, including the business modeling phase. In this paper, a consistent set of rules for the composition of concerns for the business model is presented. These rules, designed using the BPMN 2.0 standard, seeks to ensure the correct composition of diagrams, preserving the syntax of the standard notation, to substantially improve the semantic integrity of the whole model and, consequently, to reduce the appearance of conflicts that normally arise when crosscutting concerns are composed at the join points</dc:description>
</item>
<item>
<title>Making architecture optimization transparent with tactic-based explanations</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151649</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Over the past decade, a number of automated techniques and tools have been developed for optimizing architectural designs with respect to quality-attribute goals. In these systems, the optimization process is typically seen as a black box, since it is not possible for a human to have access to the decisions that led to a particular solution generated by an optimization tool. Even when these decisions are available for inspection, the amount of information can be overwhelming for the architect. As a result, humans might not completely understand the rationale behind a given solution or trust that a tool made correct decisions. To mitigate this problem, we propose a semi-automated approach for generating textual explanations for any architectural solution produced by a tool. This kind of explanation provides a summary of the key architectural tactics that were applied to achieve an optimized architecture that satisfies a set of quality-attribute objectives. In this paper, we discuss two procedures for determining the key tactics to be explained. As an initial experiment, we used a popular optimization tool to generate solutions and explanations for a small but non-trivial design space involving performance, reliability, and cost objectives. We also performed an exploratory user study to assess the effectiveness of these explanation
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151649</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Over the past decade, a number of automated techniques and tools have been developed for optimizing architectural designs with respect to quality-attribute goals. In these systems, the optimization process is typically seen as a black box, since it is not possible for a human to have access to the decisions that led to a particular solution generated by an optimization tool. Even when these decisions are available for inspection, the amount of information can be overwhelming for the architect. As a result, humans might not completely understand the rationale behind a given solution or trust that a tool made correct decisions. To mitigate this problem, we propose a semi-automated approach for generating textual explanations for any architectural solution produced by a tool. This kind of explanation provides a summary of the key architectural tactics that were applied to achieve an optimized architecture that satisfies a set of quality-attribute objectives. In this paper, we discuss two procedures for determining the key tactics to be explained. As an initial experiment, we used a popular optimization tool to generate solutions and explanations for a small but non-trivial design space involving performance, reliability, and cost objectives. We also performed an exploratory user study to assess the effectiveness of these explanation</dc:description>
</item>
<item>
<title>PQEMw, applying weighted sums to software quality measurement</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151648</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Product owners and quality leaders need to understand the quality level of a software product through its life cycle in order to achieve appropriate decision making to remain in the same iteration or to continue to the next one. Product Quality Evaluation Method (PQEM) evaluates and monitors the quality of a software product within each iteration. The present article introduces the extension of the method, PQEMwi to include the definition and calculation of weights for each quality characteristic measured. PQEMwi allows the stakeholder to set their point of view and importance of each quality characteristic, and we carried out an illustrative example of two apps, comparing the decisionmaking of the weights selection and the results of applying PQEMwi.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151648</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Product owners and quality leaders need to understand the quality level of a software product through its life cycle in order to achieve appropriate decision making to remain in the same iteration or to continue to the next one. Product Quality Evaluation Method (PQEM) evaluates and monitors the quality of a software product within each iteration. The present article introduces the extension of the method, PQEMwi to include the definition and calculation of weights for each quality characteristic measured. PQEMwi allows the stakeholder to set their point of view and importance of each quality characteristic, and we carried out an illustrative example of two apps, comparing the decisionmaking of the weights selection and the results of applying PQEMwi.</dc:description>
</item>
<item>
<title>A taxonomy for mobile location-based services functions identification</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151647</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Location-based services (LBS) are widely used. We address the problem of identifying functions of a mobile LBS for functional requirements. We found some taxonomies for LBS useful for identifying functions; in them some characteristics are too general for finding specific functions; there are not enough dimensions in these taxonomies, and some dimensions have not enough characteristics. We found papers classifying LBS into groups and for each group they present typical functions, but do not present the dimensions foridentifying all functions for an app. Our objective is to reduce these gaps. We applied Nickerson’s method to find a taxonomy for function identification. We found 3 new dimensions, and 11 new characteristics for existing dimensions. We organized several LBS groups by saying for each group which dimensions to consider and which characteristics for these dimensions to consider; this provides a new systematic way for identifying functions for an app in a group
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151647</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Location-based services (LBS) are widely used. We address the problem of identifying functions of a mobile LBS for functional requirements. We found some taxonomies for LBS useful for identifying functions; in them some characteristics are too general for finding specific functions; there are not enough dimensions in these taxonomies, and some dimensions have not enough characteristics. We found papers classifying LBS into groups and for each group they present typical functions, but do not present the dimensions foridentifying all functions for an app. Our objective is to reduce these gaps. We applied Nickerson’s method to find a taxonomy for function identification. We found 3 new dimensions, and 11 new characteristics for existing dimensions. We organized several LBS groups by saying for each group which dimensions to consider and which characteristics for these dimensions to consider; this provides a new systematic way for identifying functions for an app in a group</dc:description>
</item>
<item>
<title>ATR: template-based repair for Alloy specifications</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151646</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Automatic Program Repair (APR) is a practical research topic that studies techniques to automatically repair programs to fix bugs. Most existing APR techniques are designed for imperative programming languages, such as C and Java, and rely on analyzing correct and incorrect executions of programs to identify and repair suspicious statements. We introduce a new APR approach for software specifications written in the Alloy declarative language, where specifications are not “executed”, but rather converted into logical formulas and analyzed using backend constraint solvers, to find specification instances and counterexamples to assertions. We present ATR, a technique that takes as input an Alloy specification with some violated assertion and returns a repaired specification that satisfies the assertion. The key ideas are (i) analyzing the differences between counterexamples that do not satisfy the assertion and instances that do satisfy the assertion to guide the repair and (ii) generating repair candidates from specific templates and pruning the space of repair candidates using the counterexamples and satisfying instances.Experimental results using existing large Alloy benchmarks show that ATR is effective in generating complex repairs. ATR repairs 66.3% of 1974 fault specifications, including specification repairs that cannot be handled by existing Alloy repair techniques. ATR and all benchmarks are open-source and available in the following Github repository: https://github.com/guolong-zheng/atmprep. This work was accepted for publication at 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2022) on July 2022.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151646</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Automatic Program Repair (APR) is a practical research topic that studies techniques to automatically repair programs to fix bugs. Most existing APR techniques are designed for imperative programming languages, such as C and Java, and rely on analyzing correct and incorrect executions of programs to identify and repair suspicious statements. We introduce a new APR approach for software specifications written in the Alloy declarative language, where specifications are not “executed”, but rather converted into logical formulas and analyzed using backend constraint solvers, to find specification instances and counterexamples to assertions. We present ATR, a technique that takes as input an Alloy specification with some violated assertion and returns a repaired specification that satisfies the assertion. The key ideas are (i) analyzing the differences between counterexamples that do not satisfy the assertion and instances that do satisfy the assertion to guide the repair and (ii) generating repair candidates from specific templates and pruning the space of repair candidates using the counterexamples and satisfying instances.Experimental results using existing large Alloy benchmarks show that ATR is effective in generating complex repairs. ATR repairs 66.3% of 1974 fault specifications, including specification repairs that cannot be handled by existing Alloy repair techniques. ATR and all benchmarks are open-source and available in the following Github repository: https://github.com/guolong-zheng/atmprep. This work was accepted for publication at 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA 2022) on July 2022.</dc:description>
</item>
<item>
<title>Integrating cardinality constraints into constraint logic programming with sets</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151644</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Formal reasoning about finite sets and cardinality is important for many applications, including software verification, where very often one needs to reason about the size of a given data structure. The Constraint Logic Programming tool {log} (‘setlog’) provides a decision procedure for deciding the satisfiability of formulas involving very general forms of finite sets, although it does not provide cardinality constraints. In this paper we adapt and integrate a decision procedure for a theory of finite sets with cardinality into {log}. The proposed solver is proved to be a decision procedure for its formulas. Besides, the new CLP instance is implemented as part of the {log} tool. In turn, the implementation uses Howe and King’s Prolog SAT solver and Prolog’s CLP(Q) library, as an integer linear programming solver. The empirical evaluation of this implementation based on +250 real verification conditions shows that it can be useful in practice.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151644</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Formal reasoning about finite sets and cardinality is important for many applications, including software verification, where very often one needs to reason about the size of a given data structure. The Constraint Logic Programming tool {log} (‘setlog’) provides a decision procedure for deciding the satisfiability of formulas involving very general forms of finite sets, although it does not provide cardinality constraints. In this paper we adapt and integrate a decision procedure for a theory of finite sets with cardinality into {log}. The proposed solver is proved to be a decision procedure for its formulas. Besides, the new CLP instance is implemented as part of the {log} tool. In turn, the implementation uses Howe and King’s Prolog SAT solver and Prolog’s CLP(Q) library, as an integer linear programming solver. The empirical evaluation of this implementation based on +250 real verification conditions shows that it can be useful in practice.</dc:description>
</item>
<item>
<title>InspectJS: leveraging code similarity and user-feedback for effective taint specification inference for JavaScript</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151643</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Static analysis has established itself as a weapon of choice for detecting security vulnerabilities. Taint analysis in particular is a very general and powerful technique, where security policies are expressed in terms of forbidden flows, either from untrusted input sources to sensitive sinks (in integrity policies) or from sensitive sources to untrusted sinks (in confidentiality policies). The appeal of this approach is that the tainttracking mechanism has to be implemented only once, and can then be parameterized with different taint specifications (that is, sets of sources and sinks, as well as any sanitizers that render otherwise problematic flows innocuous) to detect many different kinds of vulnerabilities.But while techniques for implementing scalable inter-procedural static taint tracking are fairly well established, crafting taint specifications is still more of an art than a science, and in practice tends to involve a lot of manual effort.Past work has focussed on automated techniques for inferring taint specifications for libraries either from their implementation or from the way they tend to be used in client code. Among the latter, machine learningbased approaches have shown great promise. In this work we present our experience combining an existing machinelearning approach to mining sink specifications for JavaScript libraries with manual taint modelling in the context of GitHub’s CodeQL analysis framework. We show that the machine-learning component can successfully infer many new taint sinks that either are not part of the manual modelling or are not detected due to analysis incompleteness. Moreover, we present techniques for organizing sink predictions using automated ranking and code-similarity metrics that allow an analysis engineer to efficiently sift through large numbers of predictions to identify true positives. Published in: 2022 IEEE/ACM 44th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP).
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151643</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Static analysis has established itself as a weapon of choice for detecting security vulnerabilities. Taint analysis in particular is a very general and powerful technique, where security policies are expressed in terms of forbidden flows, either from untrusted input sources to sensitive sinks (in integrity policies) or from sensitive sources to untrusted sinks (in confidentiality policies). The appeal of this approach is that the tainttracking mechanism has to be implemented only once, and can then be parameterized with different taint specifications (that is, sets of sources and sinks, as well as any sanitizers that render otherwise problematic flows innocuous) to detect many different kinds of vulnerabilities.But while techniques for implementing scalable inter-procedural static taint tracking are fairly well established, crafting taint specifications is still more of an art than a science, and in practice tends to involve a lot of manual effort.Past work has focussed on automated techniques for inferring taint specifications for libraries either from their implementation or from the way they tend to be used in client code. Among the latter, machine learningbased approaches have shown great promise. In this work we present our experience combining an existing machinelearning approach to mining sink specifications for JavaScript libraries with manual taint modelling in the context of GitHub’s CodeQL analysis framework. We show that the machine-learning component can successfully infer many new taint sinks that either are not part of the manual modelling or are not detected due to analysis incompleteness. Moreover, we present techniques for organizing sink predictions using automated ranking and code-similarity metrics that allow an analysis engineer to efficiently sift through large numbers of predictions to identify true positives. Published in: 2022 IEEE/ACM 44th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP).</dc:description>
</item>
<item>
<title>Fuzzing class specifications</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151641</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Expressing class specifications via executable constraints is important for various software engineering tasks such as test generation, bug finding and automated debugging, but developers rarely write them. Techniques that infer specifications from code exist to fill this gap, but they are designed to support specific kinds of assertions and are difficult to adapt to support different assertion languages, e.g., to add support for quantification, or additional comparison operators, such as membership or containment.To address the above issue, we propose SpecFuzzer, a novel technique that combines grammar-based fuzzing, dynamic invariant detection, and mutation analysis, to automatically produce class specifications. SpecFuzzer uses: (i) a fuzzer as a generator of candidate assertions derived from a grammar that is automatically obtained from the class definition; (ii) a dynamic invariant detector –Daikon– to filter out assertions invalidated by a test suite; and (iii) a mutationbased mechanism to cluster and rank assertions, so that similar constraints are grouped and then the stronger prioritized. Fuzzing, traditionally used to efficiently produce structured random data for testing, has two key advantages in this context: (1) it eliminates the need of developers to manually define candidate assertions and (2) it enables developers to straightforwardly adapt the language of assertions by manipulating the fuzzing grammar, e.g., to include additional operators.We evaluated our technique on a benchmark of 43 Java methods employed in the evaluation of the state-of-the-art techniques GAssert and EvoSpex. In our evaluation, we used the same benchmarks from the evaluation of GAssert and EvoSpex, carefully studied the subjects, and manually produced corresponding “ground truth” assertions capturing the intended behavior of the subjects. We then used this ground truth to accurately assess precision and recall of SpecFuzzer, GAssert, and EvoSpex. Our results show that SpecFuzzer can easily support a more expressive assertion language, over which is more effective than GAssert and EvoSpex in inferring specifications, according to standard performance metrics. More precisely, SpecFuzzer was able to express ∼45% more assertions in the ground truth than these tools. Also, SpecFuzzer was able to detect 75% of all assertions in the ground truth, showing a better overall performance compared to previous techniques. The results we obtained provide initial, yet strong evidence that SpecFuzzer is effective. This work was published at the 44th International Conference on Software Engineering (ICSE 2022) held in Pittsburgh, PA, USA on 22-27 May 2022.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151641</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Expressing class specifications via executable constraints is important for various software engineering tasks such as test generation, bug finding and automated debugging, but developers rarely write them. Techniques that infer specifications from code exist to fill this gap, but they are designed to support specific kinds of assertions and are difficult to adapt to support different assertion languages, e.g., to add support for quantification, or additional comparison operators, such as membership or containment.To address the above issue, we propose SpecFuzzer, a novel technique that combines grammar-based fuzzing, dynamic invariant detection, and mutation analysis, to automatically produce class specifications. SpecFuzzer uses: (i) a fuzzer as a generator of candidate assertions derived from a grammar that is automatically obtained from the class definition; (ii) a dynamic invariant detector –Daikon– to filter out assertions invalidated by a test suite; and (iii) a mutationbased mechanism to cluster and rank assertions, so that similar constraints are grouped and then the stronger prioritized. Fuzzing, traditionally used to efficiently produce structured random data for testing, has two key advantages in this context: (1) it eliminates the need of developers to manually define candidate assertions and (2) it enables developers to straightforwardly adapt the language of assertions by manipulating the fuzzing grammar, e.g., to include additional operators.We evaluated our technique on a benchmark of 43 Java methods employed in the evaluation of the state-of-the-art techniques GAssert and EvoSpex. In our evaluation, we used the same benchmarks from the evaluation of GAssert and EvoSpex, carefully studied the subjects, and manually produced corresponding “ground truth” assertions capturing the intended behavior of the subjects. We then used this ground truth to accurately assess precision and recall of SpecFuzzer, GAssert, and EvoSpex. Our results show that SpecFuzzer can easily support a more expressive assertion language, over which is more effective than GAssert and EvoSpex in inferring specifications, according to standard performance metrics. More precisely, SpecFuzzer was able to express ∼45% more assertions in the ground truth than these tools. Also, SpecFuzzer was able to detect 75% of all assertions in the ground truth, showing a better overall performance compared to previous techniques. The results we obtained provide initial, yet strong evidence that SpecFuzzer is effective. This work was published at the 44th International Conference on Software Engineering (ICSE 2022) held in Pittsburgh, PA, USA on 22-27 May 2022.</dc:description>
</item>
<item>
<title>Empirical analysis on OpenAPI topic exploration and discovery to support the developer community</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151639</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
OpenAPI has become a dominant standard for documentation in the service-oriented software industry. OpenAPI is used in many analysis and reengineering approaches for RESTful service and microservice-based systems. An OpenAPI document has several components that are usually filled by humans using natural language (e.g. description of a certain functionality). Thus, subjectivity may lead to inconsistencies and ambiguities. Understanding what an API does is a challenging question. As a consequence, this issue could hinder developers from identifying the functionality of APIs, after reading all its components. Along this line, we argue that developers will be provided with supportive tools to find those APIs that better suit their needs. In this paper, we propose a step towards creating these kinds of tools by empirically analyzing a set of 2,000 OpenAPI documents with the goal of extracting the main topics of an API using three topic modeling algorithms. To address this issue, we focus on three tasks: i) determine which component of an OpenAPI document provides the most meaningful information, ii) compare three state-of-the-art topic modeling algorithms, and iii) determine the optimal number of topics to represent an API. Our findings show that the best results could be obtained from the Description component by using the Non-negative Matrix Factorization (NMF) or Latent Semantic Indexing (LSI) algorithms. To help developers find services in the OpenAPI directory, we also propose a prototype tool to explore the OpenAPI documents and analyze extracted topics to assess if the APIs meet developer’s needs.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151639</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>OpenAPI has become a dominant standard for documentation in the service-oriented software industry. OpenAPI is used in many analysis and reengineering approaches for RESTful service and microservice-based systems. An OpenAPI document has several components that are usually filled by humans using natural language (e.g. description of a certain functionality). Thus, subjectivity may lead to inconsistencies and ambiguities. Understanding what an API does is a challenging question. As a consequence, this issue could hinder developers from identifying the functionality of APIs, after reading all its components. Along this line, we argue that developers will be provided with supportive tools to find those APIs that better suit their needs. In this paper, we propose a step towards creating these kinds of tools by empirically analyzing a set of 2,000 OpenAPI documents with the goal of extracting the main topics of an API using three topic modeling algorithms. To address this issue, we focus on three tasks: i) determine which component of an OpenAPI document provides the most meaningful information, ii) compare three state-of-the-art topic modeling algorithms, and iii) determine the optimal number of topics to represent an API. Our findings show that the best results could be obtained from the Description component by using the Non-negative Matrix Factorization (NMF) or Latent Semantic Indexing (LSI) algorithms. To help developers find services in the OpenAPI directory, we also propose a prototype tool to explore the OpenAPI documents and analyze extracted topics to assess if the APIs meet developer’s needs.</dc:description>
</item>
<item>
<title>Evaluating students' perception of Scrum through a learning game</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151638</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Games for learning help students and professionals to incorporate new knowledge through a playful experience. With the popularization of virtual education (partially due to COVID-19), there is a need for new tools that complement virtual educational environments. To deal with this need, we present Scrum Game, a mobile application game that aims to support the Scrum software methodology teaching and training. Scrum Game offers 42 activities grouped in levels with specific learning goals. This paper reports on a controlled experiment that evaluates Scrum Game in a course with more than 160 students. We assessed Scrum Game's effectiveness in terms of (i) user performance (i.e., students' marks and number of levels/activities completed) and (ii) user experience (i.e., usability). We found that students who used Scrum Game outperformed those who did not use it. We also found that students think that Scrum Game exhibits an enjoyable user experience.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151638</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Games for learning help students and professionals to incorporate new knowledge through a playful experience. With the popularization of virtual education (partially due to COVID-19), there is a need for new tools that complement virtual educational environments. To deal with this need, we present Scrum Game, a mobile application game that aims to support the Scrum software methodology teaching and training. Scrum Game offers 42 activities grouped in levels with specific learning goals. This paper reports on a controlled experiment that evaluates Scrum Game in a course with more than 160 students. We assessed Scrum Game's effectiveness in terms of (i) user performance (i.e., students' marks and number of levels/activities completed) and (ii) user experience (i.e., usability). We found that students who used Scrum Game outperformed those who did not use it. We also found that students think that Scrum Game exhibits an enjoyable user experience.</dc:description>
</item>
<item>
<title>Enabledness-based testing of object protocols</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151635</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
A significant proportion of classes in modern software introduce or use object protocols, prescriptions on the temporal orderings of method calls on objects. This paper studies search-based test generation techniques that aim to exploit a particular abstraction of object protocols (enabledness preserving abstractions, EPAs) to find failures. We define coverage criteria over an extension of EPAs that includes abnormal method termination and define a search-based test case generation technique aimed at achieving high coverage. Results suggest that the proposed case generation technique with a fitness function that aims at combined structural and extended EPA coverage can provide better failure-detection capabilities not only for protocol failures but also forgeneral failures when compared to random testing and search-based test generation for standard structural coverage.This article was published in ACM Transactions on Software Engineering and Methodology, Volume 30. Issue 2.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151635</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>A significant proportion of classes in modern software introduce or use object protocols, prescriptions on the temporal orderings of method calls on objects. This paper studies search-based test generation techniques that aim to exploit a particular abstraction of object protocols (enabledness preserving abstractions, EPAs) to find failures. We define coverage criteria over an extension of EPAs that includes abnormal method termination and define a search-based test case generation technique aimed at achieving high coverage. Results suggest that the proposed case generation technique with a fitness function that aims at combined structural and extended EPA coverage can provide better failure-detection capabilities not only for protocol failures but also forgeneral failures when compared to random testing and search-based test generation for standard structural coverage.This article was published in ACM Transactions on Software Engineering and Methodology, Volume 30. Issue 2.</dc:description>
</item>
<item>
<title>Automation tools for web testing: beyond selenium</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151633</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
In today’s fast-paced world of software development, automation test tools proved to be of great importance in building a robust product while delivering quality software faster. To keep up with everchanging demand, organizations are embracing test automation. The goal of automation test tools has shifted from shortening test times to better coverage and effective use of test cases. Selenium is a familiar, longstanding, and well-known name in the market of test automation. It is considered the industry standard for web application user interface automation testing. But as it happens most of the time, it also has certain limitations. There are other test-automation systems with good features available in the market. The goal of this article is to review and analyze them as a Selenium alternative
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151633</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>In today’s fast-paced world of software development, automation test tools proved to be of great importance in building a robust product while delivering quality software faster. To keep up with everchanging demand, organizations are embracing test automation. The goal of automation test tools has shifted from shortening test times to better coverage and effective use of test cases. Selenium is a familiar, longstanding, and well-known name in the market of test automation. It is considered the industry standard for web application user interface automation testing. But as it happens most of the time, it also has certain limitations. There are other test-automation systems with good features available in the market. The goal of this article is to review and analyze them as a Selenium alternative</dc:description>
</item>
<item>
<title>Data-driven storytelling to support decision making in crisis settings: a case study</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151631</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Data-driven storytelling helps to communicate facts, easing comprehension and decision making, particularly in crisis settings such as the current COVID-19 pandemic.&#13;
Several studies have reported on general practices and guidelines to follow in order to create effective narrative visualizations. However, research regarding the benefits of implementing those practices and guidelines in software development is limited.&#13;
In this article, we present a case study that explores the benefits of including data visualization best practices in the development of a software system for the current health crisis, as well as the impact of not doing so. The system had high volatility in its requirements and short development cycles, prioritizing the delivery of functionality and real-time visualizations. This meant that narrative and visual aspects were set aside and that only some best practices were followed by the development team.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151631</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Data-driven storytelling helps to communicate facts, easing comprehension and decision making, particularly in crisis settings such as the current COVID-19 pandemic.&#13;
Several studies have reported on general practices and guidelines to follow in order to create effective narrative visualizations. However, research regarding the benefits of implementing those practices and guidelines in software development is limited.&#13;
In this article, we present a case study that explores the benefits of including data visualization best practices in the development of a software system for the current health crisis, as well as the impact of not doing so. The system had high volatility in its requirements and short development cycles, prioritizing the delivery of functionality and real-time visualizations. This meant that narrative and visual aspects were set aside and that only some best practices were followed by the development team.</dc:description>
</item>
<item>
<title>µBert: mutation testing using pre-trained language models</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151630</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Mutation testing seeds faults using a predefined set of simple syntactic transformations, aka mutation operators, that are (typically) defined based on the grammar of the targeted programming language. As a result, mutation operators often alter the program semantics in ways that often lead to unnatural code (unnatural in the sense that the mutated code is unlikely to be produced by a competent programmer).&#13;
Such unnatural faults may not be convincing for developers as they might perceive them as unrealistic/uninteresting, thereby hindering the usability of the method. Additionally, the use of unnatural mutants may have actual impact on the guidance and assessment capabilities of mutation testing. This is because unnatural mutants often lead to exceptions, or segmentation faults, infinite loops and other trivial cases.&#13;
To deal with this issue, we propose forming mutants that are in some sense natural; meaning that the mutated code/statement follows the implicit rules, coding conventions and generally representativeness of the code produced by competent programmers. We define/capture this naturalness of mutants using language models trained on big code that learn (quantify) the occurrence of code tokens given their surrounding code.&#13;
We introduce µBert, a mutation testing tool that uses a pre-trained language model (CodeBERT) to generate mutants. This is done by masking a token from the expression given as input and using CodeBERT to predict it.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151630</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Mutation testing seeds faults using a predefined set of simple syntactic transformations, aka mutation operators, that are (typically) defined based on the grammar of the targeted programming language. As a result, mutation operators often alter the program semantics in ways that often lead to unnatural code (unnatural in the sense that the mutated code is unlikely to be produced by a competent programmer).&#13;
Such unnatural faults may not be convincing for developers as they might perceive them as unrealistic/uninteresting, thereby hindering the usability of the method. Additionally, the use of unnatural mutants may have actual impact on the guidance and assessment capabilities of mutation testing. This is because unnatural mutants often lead to exceptions, or segmentation faults, infinite loops and other trivial cases.&#13;
To deal with this issue, we propose forming mutants that are in some sense natural; meaning that the mutated code/statement follows the implicit rules, coding conventions and generally representativeness of the code produced by competent programmers. We define/capture this naturalness of mutants using language models trained on big code that learn (quantify) the occurrence of code tokens given their surrounding code.&#13;
We introduce µBert, a mutation testing tool that uses a pre-trained language model (CodeBERT) to generate mutants. This is done by masking a token from the expression given as input and using CodeBERT to predict it.</dc:description>
</item>
<item>
<title>Estudios empíricos realizados con colecciones de  proyectos software: un mapeo sistemático</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151627</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Los proyectos software son insumos en la Ingeniería del Software Basada en Evidencias, aunque estos sean seleccionados sin seguir una estrategia específica, lo cual disminuye la generalización y replicación de los resultados. Una opción es usar colecciones de proyectos existentes, pero estas deben contar con reglas explícitas de construcción y mantenimiento. El objetivo de este trabajo fue realizar un estudio secundario sistematizado sobre las estrategias de selección de los proyectos software en estudios empíricos, y conocer: las reglas consideradas, las características de los proyectos, las métricas de código, las herramientas de extracción y los análisis estadísticos practicados. Se utilizó un mapeo sistemático para identificar artículos desde enero de 2013 a diciembre de 2021. Se seleccionaron 150 estudios de los cuales el 67% utilizó reglas propias para la selección de los proyectos y el 31% trabajó con colecciones existentes, y la mayoría (80%) empleó proyectos Java. Asimismo, no se encontraron evidencias de un marco estandarizado para la selección de proyectos para estudios empíricos en Ingeniería de Software.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151627</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Los proyectos software son insumos en la Ingeniería del Software Basada en Evidencias, aunque estos sean seleccionados sin seguir una estrategia específica, lo cual disminuye la generalización y replicación de los resultados. Una opción es usar colecciones de proyectos existentes, pero estas deben contar con reglas explícitas de construcción y mantenimiento. El objetivo de este trabajo fue realizar un estudio secundario sistematizado sobre las estrategias de selección de los proyectos software en estudios empíricos, y conocer: las reglas consideradas, las características de los proyectos, las métricas de código, las herramientas de extracción y los análisis estadísticos practicados. Se utilizó un mapeo sistemático para identificar artículos desde enero de 2013 a diciembre de 2021. Se seleccionaron 150 estudios de los cuales el 67% utilizó reglas propias para la selección de los proyectos y el 31% trabajó con colecciones existentes, y la mayoría (80%) empleó proyectos Java. Asimismo, no se encontraron evidencias de un marco estandarizado para la selección de proyectos para estudios empíricos en Ingeniería de Software.</dc:description>
</item>
<item>
<title>El portal de integración de IPaaS: propuesta de comparación aplicando el proceso analítico jerárquico</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151625</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
Una plataforma de integración de servicios (IPaaS) es un conjunto de servicios en la nube que permite a los usuarios crear, administrar y gobernar ujos de integración que conectan una amplia gama de aplicaciones o fuentes de datos sin instalar ni administrar ningún hardware o middleware. En los últimos años han emergido una gran cantidad de IPaaS, la selección de las mismas se plantea como un problema para los potenciales usuarios/clientes. Este trabajo propone el análisis y comparación de IPaaS considerando los recursos y servicios disponibles u ofrecidos al desarrollador en la plataforma, lo que denominamos Portal de Integración. Para este análisis se aplicó el método Proceso Analítico Jerárquico (AHP). Siguiendo este enfoque, se ha caracterizado el Portal de Integración, en cinco dimensiones y 29 atributos; y se aplicó a las IPaaS, Zapier, MuleSoft y Celigo.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151625</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>Una plataforma de integración de servicios (IPaaS) es un conjunto de servicios en la nube que permite a los usuarios crear, administrar y gobernar ujos de integración que conectan una amplia gama de aplicaciones o fuentes de datos sin instalar ni administrar ningún hardware o middleware. En los últimos años han emergido una gran cantidad de IPaaS, la selección de las mismas se plantea como un problema para los potenciales usuarios/clientes. Este trabajo propone el análisis y comparación de IPaaS considerando los recursos y servicios disponibles u ofrecidos al desarrollador en la plataforma, lo que denominamos Portal de Integración. Para este análisis se aplicó el método Proceso Analítico Jerárquico (AHP). Siguiendo este enfoque, se ha caracterizado el Portal de Integración, en cinco dimensiones y 29 atributos; y se aplicó a las IPaaS, Zapier, MuleSoft y Celigo.</dc:description>
</item>
<item>
<title>Determinación de la calidad de producto, persona y proceso en entornos de desarrollo con GitHub: un estudio sistemático de la literatura</title>
<link>http://sedici.unlp.edu.ar:80/handle/10915/151623</link>
<description>Objeto de conferencia
Simposio Argentino de Ingeniería de Software (ASSE 2022) - JAIIO 51 (Modalidad virtual y presencial (UAI), octubre 2022)
La comparación entre costo, tiempo y alcance de un proyecto de desarrollo de software y el resultado final, ha brindado una manera simple, aunque sesgada de medir la eficiencia y eficacia de un equipo de proyecto. Consideramos necesario comprender que algunas características de cada desarrollador más los resultados de un proceso creativo del equipo de trabajo dentro del ciclo de vida del Producto, incide directamente en la calidad de éste. Proponemos entonces considerar la calidad de las 3Ps: Producto, Persona y Proceso como una manera holística de determinar la calidad total en la Ingeniería de Software. Pretendemos encontrar métricas objetivas para las 3Ps cuya fuente de datos sea GitHub. De un estudio sistemático de la literatura realizado, los resultados muestran que los estudios previos se centraron en la definición de métricas calculables desde metadata de GitHub para proyectos de código abierto y sin foco en las 3Ps.
</description>
<pubDate>Sat, 01 Jan 2022 00:00:00 GMT</pubDate>
<guid isPermaLink="false">http://sedici.unlp.edu.ar:80/handle/10915/151623</guid>
<dc:date>2022-01-01T00:00:00Z</dc:date>
<dc:description>La comparación entre costo, tiempo y alcance de un proyecto de desarrollo de software y el resultado final, ha brindado una manera simple, aunque sesgada de medir la eficiencia y eficacia de un equipo de proyecto. Consideramos necesario comprender que algunas características de cada desarrollador más los resultados de un proceso creativo del equipo de trabajo dentro del ciclo de vida del Producto, incide directamente en la calidad de éste. Proponemos entonces considerar la calidad de las 3Ps: Producto, Persona y Proceso como una manera holística de determinar la calidad total en la Ingeniería de Software. Pretendemos encontrar métricas objetivas para las 3Ps cuya fuente de datos sea GitHub. De un estudio sistemático de la literatura realizado, los resultados muestran que los estudios previos se centraron en la definición de métricas calculables desde metadata de GitHub para proyectos de código abierto y sin foco en las 3Ps.</dc:description>
</item>
</channel>
</rss>
