Search

In this paper, we propose to use production executions to improve the quality of testing for certain methods of interest for developers. These methods can be methods that are not covered by the existing test suite, or methods that are poorly tested. We devise an approach called PANKTI which monitors applications as they execute in production, and then automatically generates differential unit tests, as well as derived oracles, from the collected data. PANKTI's monitoring and generation focuses on one single programming language, Java. We evaluate it on three real-world, open-source projects: a videoconferencing system, a PDF manipulation library, and an e-commerce application. We show that PANKTI is able to generate differential unit tests by monitoring target methods in production, and that the generated tests improve the quality of the test suite of the application under consideration.

In pull-based development process, contributors submit their code to open-source projects by pull requests, which are accepted or rejected by reviewers. Contributors may modify their code, which causes several iterations of code review process, and makes code reviews time-consuming for both contributors and reviewers. In this article, we set out to study pull request modifications in a code review process. We collect nine projects on GitHub with 104 307 pull requests, and investigate pull request modifications through analyzing added commits after pull requests’ submission. By studying four research questions, we conclude our major findings as follow. First, 34.56% of collected pull requests have modifications. Pull requests with modifications have longer lifetime but higher pass rates. Second, we conclude eight modification types indicating why pull requests are modified. Third, we propose a novel method called MClassify to automatically classify pull request modifications, which achieves the accuracy of 0.807. Fourth, various modification types affect code review differently from the perspective of lifetime and pass rate. Pull requests with source control system management modifications have the longest lifetime. These findings enable developers and researchers to understand a pull-based code review process better and make improvements.

Reusability is a central concept of Web services as it allows for the construction of composite Web services at lower cost/effort. Web services offer diverse functional capabilities ({\it e.g.,} ticket purchase, hotel booking) and inherent transactional properties. However, due to the lack of an explicit and formal description of these functional and transactional perspectives, the correctness of the transactional reliability and functional properties cannot be verified. The composite Web service reliability is computed using a set of transactional requirements defined by designers throughout the Accepted Termination States (ATS) concept. The main objective of this paper is to introduce a formal model of the Web service configuration and its correctness requirements that permit to ensure the correct Web service execution from functional and transactional points of view. For that purpose, we developed a Correct Configuration Model for Transactional Composite Services (CCM4TCS) using the \eventB method. This model is used to formally validate the consistency of composite Web service configuration's properties and requirements. It allows also to check the correctness of ATS constraints that we use as reliability parameters. The correctness and the validation of our model are ensured by discharging proof obligations and by animating the specification using the ProB model-checker

Web3.0, often cited to drastically shape our lives, is ubiquitous. However, few literatures have discussed the crucial differentiators that separate Web3.0 from the era we are currently living in. Via a thorough analysis of the recent blockchain infrastructure evolution, we capture a key invariant featuring the evolution, based on which we provide the first academic definition for Web3.0. Our definition is not the only way of understanding Web3.0, yet, it captures the fundamental and defining trait of Web3.0, and meanwhile it is has two desirable properties. Under this definition, we articulate three key infrastructural enablers for Web3.0: individual blockchains, federated or centralized platforms capable of publishing verifiable states, and an interoperability platform to hyperconnect those state publishers. While innovations in all categories are necessary to fully enable Web3.0, in this paper, we present a design for the third enabler, namely HyperService, that delivers interoperability and programmability across heterogeneous blockchains and state publishers. HyperService is powered by two innovative designs: a developer-facing programming framework that allows developers to build cross-chain applications in a unified programming model; and a secure blockchain-facing cryptography protocol that provably realizes those applications on blockchains. We implement a prototype of HyperService in 62,000 lines of code to demonstrate its practicality, usability, and scalability.

In recent years, Python has experienced explosive growth in adoption, particularly among open source projects. While Python's dynamically-typed nature provides developers with powerful programming abstractions, that same dynamic type system allows for type-related defects to accumulate in code bases. To aid in the early detection of type-related defects, type annotations were introduced into the Python ecosystem (i.e., PEP-484) and static type checkers like mypy have appeared on the market. While applying a type checker like mypy can in theory help to catch type-related defects before they impact users, little is known about the real impact of adopting a type checker to reveal defects in Python projects. In this paper, we study the extent to which Python projects benefit from such type checking features. For this purpose, we mine the issue tracking and version control repositories of 210 Python projects on GitHub. Inspired by the work of Gao et al. on type-related defects in JavaScript, we add type annotations to test whether detects an error that would have helped developers to avoid real defects. We observe that 15% of the defects could have been prevented by mypy. Moreover, we find that there is no significant difference between the experience level of developers committing type-related defects and the experience of developers committing defects that are not type-related. In addition, a manual analysis of the anti-patterns that most commonly lead to type-checking faults reveals that the redefinition of Python references, dynamic attribute initialization and incorrectly handled Null objects are the most common causes of type-related faults. Since our study is conducted on fixed public defects that have gone through code reviews and multiple test cycles, these results represent a lower bound on the benefits of adopting a type checker. Therefore, we recommend incorporating a static type checker like mypy into the development workflow, as not only will it prevent type-related defects but also mitigate certain anti-patterns during development.

Different web services can be composed to perform increasingly complex tasks (e.g., making an on-line payment). However, existing approaches compose web services with hard-coded control and data flows. To proactively and autonomously compose web services, developers can develop agents. However, the development of agents for service composition is complex, due to the reasons that: 1) developers may not have the knowledge from various domains to identify the necessary tasks to carry out the required web services; and 2) a deep understanding of the agent specific code is required in order to implement agents. To alleviate the required efforts to develop agents, we propose an approach to separate the development of agent specific code from the business logic code in the service composition. More specifically, we provide an easy-to-understand syntax that abstracts agent specific code and automatically generates executable agent code. Our experimental results show that our approach can accurately identify tasks for service composition with an Area Under the Curve (AUC) of 0.88. Our experiments also demonstrate that our approach can correctly generate agent code from seven agent specifications. Finally, our user studies reveal that developers are satisfied with our approach to develop agents for service composition.

An energy efficient information and communication system is a need of the day. Information technology related industries are making efforts to reduce power consumption by improvising both the hardware infrastructure and software systems. The hardware is driven by software; hence, design and development of software may have a significant impact energy need of the overall system. Many times it is observed that complex software performs useless tasks leading to power consumption, referred to as energy leak. The solution of energy leaks for mobile applications has attracted the interest of researchers, but still handling energy leaks issues for applications developed using Java-based technology need to be explored. While designing software during maintenance phase, code smells are introduced which not only reduce performance of the software also may lead to execution of useless code thus enhancing the energy leak. The common practice of the software industry to remove the code smells is use of refactoring strategy. The basic idea of this study is to understand the impact of refactoring on total energy consumption. To explore this hypothesis a set of Java based applications are selected, code smell present in these applications are discovered and a suitable refactoring strategy is applied to reduce the code smell. Power consumption is estimated using an open source tool Microsoft Joulemeter, it monitors energy usage by machine resources and estimates power consumption. The energy consumption before and after refactoring is recorded and statistical t-test is performed to validate the proposed concept.

Business process compliance ensures that the processes of an organisation are designed and executed according to the rules that govern it. We faced the challenge of building a compliance management system for a process-aware organisation and identified several needs that, despite having been identified in the literature, were only partially satisfied by existing approaches. The variability in the types of rules generally restricts the existing support for compliance checking to specific types of rules, a concrete phase of the business process management lifecycle, or certain information systems (ISs) for data retrieval. Motivated by this, we designed a conceptual framework for compliance checking that relies on the use of mashups for rule specification and checking, with the following advantages: (i) an open-ended set of rules can be specified by designing and connecting mashup components; (ii) (parts of) the definitions of the rules can be reused as needed; and (iii) the mashup-based compliance checking system can be integrated with ISs of the organisation, enabling the verification of actual facts on actions performed during the execution of a process (e.g., the existence of a document in a location). Design-time and run-time implementations of the framework were conducted and tested in a real setting.

This work proposes a cloud solution to build an Internet of Things (IoT) platform applied in a greenhouse crop production context. Real-time and historical data, as well as prediction models, can be accessed by means of RESTful (Representational State Transfer) web services developed for such a purpose. Forecasting is also provided following a Greenhouse Models as a Service (GMaaS) approach. Currently, our GMaaS tool provides forecasting based on computational models developed for inside climate, crop production and irrigation processes. Traditionally, such models are hardcoded in applications or are embedded in software tools to be used as Decision Support Systems (DSS). However, using a GMaaS approach, models are available as RESTful services to be used as needed. In addition, the proposed platform allows users to register new IoT devices and their greenhouse data in the FIWARE platform, providing a cloud scale solution for the case study. RESTful services of the proposed platform are also used by a web application allowing users to interact easily with the system.

Due to the conflicting nature of quality measures, there are always multiple refactoring options to fix quality issues. Thus, interaction with developers is critical to inject their preferences. While several interactive techniques have been proposed, developers still need to examine large numbers of possible refactorings, which makes the interaction time-consuming. Furthermore, existing interactive tools are limited to the "objective space" to show developers the impacts of refactorings on quality attributes. However, the "decision space" is also important since developers may want to focus on specific code locations. In this paper, we propose an interactive approach that enables developers to pinpoint their preference simultaneously in the objective (quality metrics) and decision (code location) spaces. Developers may be interested in looking at refactoring strategies that can improve a specific quality attribute, such as extendibility (objective space), but they are related to different code locations (decision space). A plethora of solutions is generated at first using multi-objective search that tries to find the possible trade-offs between quality objectives. Then, an unsupervised learning algorithm clusters the trade-off solutions based on their quality metrics, and another clustering algorithm is applied to each cluster of the objective space to identify solutions related to different code locations. The objective and decision spaces can now be explored more efficiently by the developer, who can give feedback on a smaller number of solutions. This feedback is then used to generate constraints for the optimization process, to focus on the developer's regions of interest in both the decision and objective spaces. The manual validation of selected refactoring solutions by developers confirms that our approach outperforms state of the art refactoring techniques.

The development and evaluation of Mission Engineering Threads (METs) require an understanding of the operational context for which a system-of-systems (SoS) will be employed as well as an assessment that the performance of a complex SoS is effective and safe. The information describing the design and performance parameters of the systems within the SoS is distributed in many different physical locations, and is represented in a variety of formats, both structured and unstructured. Because of this dynamic on the structuring of the data to include differing ontology frameworks, it is necessary to develop a framework and toolset to handle the automated extraction of information from disparate information sources. In addition, this extracted information needs to be categorized properly into defined data types as represented in the specific MET to correctly capture the appropriate context of the mission scenario. Semantic technique solutions will be researched, analysed, and applied as a means to infer new facts from existing facts and data. These techniques are particularly powerful when the amount of data and/or the relationships and constraints among data are too cumbersome and complex for human understanding and reasoning. Using the characteristics of wine as an example, we present our framework to show how it enables rapid and contextually relevant extraction, and represents complex information in a user-friendly format.

With today's rapidly-evolving cloud landscape embracing continuous integration and delivery, users of cloud systems must monitor software running on their containers and virtual machines (VMs) to ensure compliance, security, and efficiency. Traditional solutions to this problem rely on manually-created rules that identify software installations and modifications, but these require expert authors and are often unmaintainable. Recently, automated techniques for software discovery have emerged. Some techniques use examples of software to train machine learning models to predict which software has been installed on a system. Others leverage knowledge of packaging practices to aid in discovery without requiring any pre-training, but these practice-based methods cannot provide precise-enough information to perform discovery by themselves. This paper introduces Praxi, a new software discovery method that builds upon the strengths of prior approaches by combining the accuracy of learning-based methods with the efficiency of practice-based methods. In tests using samples collected on real-world cloud systems, Praxi correctly classifies installations at least 97.6% of the time, while running 14.8 times faster and using 87% less disk space than a similar learning-based method. Using a diverse software dataset, this paper quantitatively compares Praxi to systematic rule-, learning-, and practice-based methods, and discusses the best uses for each.

Component Based Software Engineering has one main sole motive of making the development process of software systems as easy as possible and to achieve this objective work needs to be done in previous systems to identify the concerns and limitations which can be overcome using this software engineering based approach. In this paper to support concept of component based system a domain is chosen that covers the GIS systems. GIS (Geographic Information Systems) are commonly used for development of map based applications these systems are widely used across the web and in various organizations. With the development and deepening of GIS, traditional GIS systems showed the challenges on isolation, sealing, interoperability and the limitations, thereby hindering further development and application of GIS technology. In this paper framework for component based GIS system is proposed. This framework is having rich graphical interface and user data can be easily retrieved from the connected database and displayed in the browser.

This paper discusses an implementation of a declarative style of programming for sensor-based applications, involving the acquisition and aggregation of context. We describe an implementation of LogicCAP integrating Prolog with the ContextToolkit, and its on-going extensions, considering applications in the mobile environment, distributed evaluation, and dynamic sensor binding issues. We also propose LogicCAP as a declarative language for context (and sensor) mashups with the situation as the aggregating abstraction.

Developing and optimizing software applications for high performance and energy efficiency is a very challenging task, even when considering a single target machine. For instance, optimizing for multicore-based computing systems requires in-depth knowledge about programming languages, application programming interfaces, compilers, performance tuning tools, and computer architecture and organization. Many of the tasks of performance engineering methodologies require manual efforts and the use of different tools not always part of an integrated toolchain. This paper presents Pegasus, a performance engineering approach supported by a framework that consists of a source-to-source compiler, controlled and guided by strategies programmed in a Domain-Specific Language, and an autotuner. Pegasus is a holistic and versatile approach spanning various decision layers composing the software stack, and exploiting the system capabilities and workloads effectively through the use of runtime autotuning. The Pegasus approach helps developers by automating tasks regarding the efficient implementation of software applications in multicore computing systems. These tasks focus on application analysis, profiling, code transformations, and the integration of runtime autotuning. Pegasus allows developers to program their strategies or to automatically apply existing strategies to software applications in order to ensure the compliance of non-functional requirements, such as performance and energy efficiency. We show how to apply Pegasus and demonstrate its applicability and effectiveness in a complex case study, which includes tasks from a smart navigation system.

Computers have become a huge requirement to support human performance. Computers also often experience Hardware damage such as processors, VGA, motherboards, memory, mouse, keyboards, hard disks, optical drives, monitors. Until now, many computer users still do not have sufficient knowledge of the initial diagnosis of computer Hardware damage which causes a lot of computer users to pay a lot of money to find out and repair the damage that occurs to Computer Hardware. In this Expert System application research development, the authors use a combination of two inference methods, namely the Forward Chaining method and the Certainty Factor Method. The programming tools used in the development of this Expert System application is using the Sublime Text 3 application while the database uses MySQL with PHP as the programming language. The purpose of this Expert System application is made to assist computer users in making an initial diagnosis of a damaged computer Hardware along with the causes and solutions to overcome the damage.

Identifying refactoring operations in source code changes is valuable to understand software evolution. Therefore, several tools have been proposed to automatically detect refactorings applied in a system by comparing source code between revisions. The availability of such infrastructure has enabled researchers to study refactoring practice in large scale, leading to important advances on refactoring knowledge. However, although a plethora of programming languages are used in practice, the vast majority of existing studies are restricted to the Java language due to limitations of the underlying tools. This fact poses an important threat to external validity. Thus, to overcome such limitation, in this paper we propose RefDiff 2.0, a multi-language refactoring detection tool. Our approach leverages techniques proposed in our previous work and introduces a novel refactoring detection algorithm that relies on the Code Structure Tree (CST), a simple yet powerful representation of the source code that abstracts away the specificities of particular programming languages. Despite its language-agnostic design, our evaluation shows that RefDiff's precision (96%) and recall (80%) are on par with state-of-the-art refactoring detection approaches specialized in the Java language. Our modular architecture also enables one to seamless extend RefDiff to support other languages via a plugin system. As a proof of this, we implemented plugins to support two other popular programming languages: JavaScript and C. Our evaluation in these languages reveals that precision and recall ranges from 88% to 91%. With these results, we envision RefDiff as a viable alternative for breaking the single-language barrier in refactoring research and in practical applications of refactoring detection.

Building information modelling (BIM) represents a workflow whose application on a construction project will enable all involved players to compile as well as work with information on every aspect of a building in a common model/database. Through BIM, the entire building can be virtually designed and built on a computer. BIM touches every part of a building’s life cycle starting from the design phase well into the construction phase and beyond that into asset management. This research examines the experiences of early adopters of BIM and use that insight to introduce BIM, specially focusing on the structural analysis and design stage of a building. The study demonstrates how all structural design activities can be integrated with each other and how cross-discipline collaboration with the architect can be achieved through the adoption of BIM without leaving ones customary structural design platform. As a demonstration, a sample building is modelled using Revit along with conventional structural software packages ETABS and SAFE. Plugins and applications were developed for these software packages to facilitate interoperability amongst them so that they all act together as a single platform. Modelling, analysis, design and clash detections were facilitated by applying BIM. Major benefits of employing BIM in a structural design project are illustrated through this research.

Tradicionalmente, durante la evaluación de un plan de radioterapia se analizan índices dosimétricos de los volúmenes contorneados empleando diversas utilidades comerciales. Para facilitar esta labor repetitiva y tediosa, y adaptarla a cada departamento, el sistema de planificación Eclipse ofrece al usuario la posibilidad de crear programas informáticos (scripts) con la ayuda de una interfaz que explora la información dosimétrica del plan. Presentamos un script de Eclipse realizado con elementos gráficos de Windows para el análisis de planes de radioterapia externa en nuestro hospital. Consideramos que este trabajo puede servir de ejemplo y resultar de utilidad para los profesionales usuarios de Eclipse.

Recent enhancements in computer aided design and manufacturing have made dentistry workflow more effective. Dental products are highly customized and personalized for patients. So, they require man...

A representation of complex high-tech digital projects is proposed in the form of a directed graph that combines input, output and intermediate data with software modules into a single bundle. This representation makes it possible to consider a digital project as an informational and algorithmic unit of technical and economic interaction that do not require additional acquisition and development of software or hardware. The project in this form is created and operated on a single multi-party cloud platform for high-performance computing, which is accessible to both scientific and engineering personnel of all participants within their access rights. This approach evolves the open innovation concept for digital projects and is implemented as a cloud-based Internet platform. The latter includes a central application server and a repository that stores both algorithms and data, provides means for user registration and maintenance, communication, as well as accounting for the resource usage in form of algorithms and data in solving application problems. As a confirmation of the fundamental adequacy of the proposed approach, a working prototype of such system is presented together with a list of projects in various domain areas implemented using the prototype.

In the new era of blockchain-based multi-agent robotic systems, smart contract programs perform an influential role in implementing decentralized applications with required task allocations. Smart contract programs are developed using script-type of programming languages, and they have already deployed several vulnerable patterns without proper testing and audit. We studied Solidity smart contracts running on the Ethereum platform and identified that they had been exploited because of several programming issues, especially using low-level external calls to malicious sources. Since smart contracts are immutable after their deployment to autonomous multi-robot systems, they should be tested to fix possible development phase issues. We implemented a prototype plugin called SolGuard by extending the solhint linter to prevent three critical issues related to Solidity smart contract programs’ usage of external calls. The SolGuard plugin checks state variable order in the smart contracts, participation of delegatecall invocations, address type parameters in the smart contract’s constructor, and denial of service patterns. We empirically evaluate the SolGuard plugin with existing popular static analysis tools. Our results indicate that SolGuard outperformed the baseline tools in terms of efficiency and accuracy.

Quantum computing is now a reality, and its incomparable computational power has led companies to show a great interest in being able to work with quantum software in order to support part of their current and future business operations. However, the quantum computing paradigm differs significantly from its classical counterparts, which has brought about the need to revolutionise how the future software is designed, built, and operated in order to work with quantum computers. Since companies cannot discard all their current (and probably mission-critical) information systems, they must adapt their classical information systems to new specific quantum applications, thus evolving towards hybrid information systems. Unfortunately, there are no specific methods with which to deal with this challenge. We believe that reengineering, and more specifically, software modernisation using model-driven engineering principles, could be useful as regard migrating classical systems and existing quantum programs towards hybrid information systems. This paper, therefore, presents QRev, a reverse engineering tool that analyses quantum programs developed in Q# in order to identify its components and interrelationships, and then generates abstract models that can be used in software modernisation processes. The platform-independent models are generated according to the Knowledge Discovery Metamodel (KDM) standard. QRev is validated in a case study involving five quantum programs in order to demonstrate its effectiveness and scalability. The main implication of the study is that QRev can be used in order to attain KDM models, which can subsequently be employed to restructure or add new quantum functionality at a higher abstraction level, i.e. independently of the specific quantum technology.

Use of third-party libraries is extremely common in application software. The libraries evolve to accommodate new features or mitigate security vulnerabilities, thereby breaking the Application Programming Interface(API) used by the software. Such breaking changes in the libraries may discourage client code from using the new library versions thereby keeping the application vulnerable and not up-to-date. We propose a novel output-oriented program synthesis algorithm to automate API usage adaptations via program transformation. Our aim is not only to rely on the few example human adaptations of the clients from the old library version to the new library version, since this can lead to over-fitting transformation rules. Instead, we also rely on example usages of the new updated library in clients, which provide valuable context for synthesizing and applying the transformation rules. Our tool APIFix provides an automated mechanism to transform application code using the old library versions to code using the new library versions - thereby achieving automated API usage adaptation to fix the effect of breaking changes. Our evaluation shows that the transformation rules inferred by APIFix achieve 98.7% precision and 91.5% recall. By comparing our approach to state-of-the-art program synthesis approaches, we show that our approach significantly reduces over-fitting while synthesizing transformation rules for API usage adaptations.

How working statically-typed functional programmers write code is largely understudied. And yet, a better understanding of developer practices could pave the way for the design of more useful and usable tooling, more ergonomic languages, and more effective on-ramps into programming communities. The goal of this work is to address this knowledge gap: to better understand the high-level authoring patterns that statically-typed functional programmers employ. We conducted a grounded theory analysis of 30 programming sessions of practicing statically-typed functional programmers, 15 of which also included a semi-structured interview. The theory we developed gives insight into how the specific affordances of statically-typed functional programming affect domain modeling, type construction, focusing techniques, exploratory and reasoning strategies, and expressions of intent. We conducted a set of quantitative lab experiments to validate our findings, including that statically-typed functional programmers often iterate between editing types and expressions, that they often run their compiler on code even when they know it will not successfully compile, and that they make textual program edits that reliably signal future edits that they intend to make. Lastly, we outline the implications of our findings for language and tool design. The success of this approach in revealing program authorship patterns suggests that the same methodology could be used to study other understudied programmer populations.

Web service composition allows developers to create applications via reusing available services that are interoperable to each other. The process of selecting relevant Web services for a composite service satisfying the developer requirements is commonly acknowledged to be hard and challenging, especially with the exponentially increasing number of available Web services on the Internet. The majority of existing approaches on Web Services Selection are merely based on the Quality of Service (QoS) as a basic criterion to guide the selection process. However, existing approaches tend to ignore the service design quality, which plays a crucial role in discovering, understanding, and reusing service functionalities. Indeed, poorly designed Web service interfaces result in service anti-patterns, which are symptoms of bad design and implementation practices. The existence of anti-pattern instances in Web service interfaces typically complicates their reuse in real-world service-based systems and may lead to several maintenance and evolution problems. To address this issue, we introduce a new approach based on the Multi-Objective and Optimization on the basis of Ratio Analysis method (MOORA) as a multi-criteria decision making (MCDM) method to select Web services based on a combination of their (1) QoS attributes and (2) QoS design. The proposed approach aims to help developers to maintain the soundness and quality of their service composite development processes. We conduct a quantitative and qualitative empirical study to evaluate our approach on a Quality of Web Service dataset. We compare our MOORA-based approach against four commonly used MCDM methods as well as a recent state-of-the-art Web service selection approach. The obtained results show that our approach outperforms state-of-the-art approaches by significantly improving the service selection quality of top- k selected services while providing the best trade-off between both service design quality and desired QoS values. Furthermore, we conducted a qualitative evaluation with developers. The obtained results provide evidence that our approach generates a good trade-off for what developers need regarding both QoS and quality of design. Our selection approach was evaluated as “relevant” from developers point of view, in improving the service selection task with an average score of 3.93, compared to an average of 2.62 for the traditional QoS-based approach.

Writing population analysis reports that fulfilling the specifications of submission readiness is a time‐consuming process and prone to human error. Thus, there is a need to streamline the creation of these reports through elements of standardization and automation. LaTeX is considered a suitable program package capable of creating long, modular, structured documents, and, because of its typographic quality, includes formula typesetting. The presented automation scripts together with easily adjustable LaTeX templates are designed to enable the reader to understand and reproduce a typical workflow from analysis to reporting. The focus of this tutorial is to use an example of a population pharmacokinetic analysis to show how to work with the proposed automated structures allowing even a reader new to the concept of LaTeX to automatize the reporting workflow and customize the templates for their specific needs.

Junto al primer robot manipulador, el UNIMATE de Devol y Engelberger, nació la preocupación de investigadores e ingenieros por demostrar el potencial de autómatas similares en aplicaciones industriales. En consecuencia muchas prestigiosas universidades percibieron cuán importante era incluir asignaturas del área en planes de estudios de carreras como Ingeniería Eléctrica, Electrónica, Mecánica o Mecatrónica. La presente investigación fue bajo el método constructivista y el análisis de resultados se apoya en la respuesta observada en un simulador mediante el uso combinado de una Toolbox para modelación cinemática de robots (basada en scripts ejecutables en un entorno como GNU Octave o similar), además de un software para simulación 3D. La ejemplificación del uso de las herramientas y el reto al estudiante de programar RI virtuales en escenarios típicos de manufactura, empaquetado o paletizado, ha sido probado a lo largo de cuatro períodos lectivos, obteniéndose una realimentación positiva de los aprobados y egresados. Los resultados alcanzados al simular demuestran la exactitud de los modelos cinemáticos obtenidos mediante formulaciones matemáticas, lo cual evidencia la utilidad de las herramientas descritas para el aprendizaje a distancia basado en la práctica.

Introduction. Based on the trends, the growing interest in VR technology in construction can be traced. This relatively new technology is rapidly replacing traditional visualization methods, providing users with an enhanced digital experience. The aim of the work is to analyze the application of virtual reality technology in construction, based on the analysis, determine how to improve integration and find new ideas for the application of technologies.Methods and materials. As a result of the analysis of previous studies, it was revealed that there are no methods for transferring data from the VR system to the BIM software. In connection with the identified problem, the goal of this scientific work is to improve the integration of VR and BIM technologies by automatically transferring data from a virtual reality program to the original information model.Results. In the course of the work, a project was created based on a BIM model made in the Autodesk Revit software package and imported into the Unreal Engine 4 game engine to create an interactive virtual environment. A new approach to the creation and presentation of a project sketch using virtual reality technology is considered - a method of intuitive design in a virtual environment.Discussion and conclusion. The software module is at the stage of early development; nevertheless, it has prospects for development into a full-fledged application available to any user. The paper provides the main directions for the continuation of the application development.

This paper introduces the APIA architecture for policy-aware intentional agents. These agents, acting in changing environments, are driven by intentions and yet abide by domain-relevant policies. This work leverages the AIA architecture for intention-driven intelligent agents by Blount, Gelfond, and Balduccini. It expands AIA with notions of policy compliance for authorization and obligation policies specified in the language AOPL by Gelfond and Lobo. APIA introduces various agent behavior modes, corresponding to different levels of adherence to policies. APIA reasoning tasks are reduced to computing answer sets using the Clingo solver and its Python API., In Proceedings ICLP 2021, arXiv:2109.07914

The Arjuna transaction system began life in the mid 1980s as an academic project to examine the use of object-oriented techniques in the development of fault-tolerant distributed systems. Twenty five years later, it is an integral part of the JBoss application sever middleware from Red Hat. This journey from an academic to a commercial environment has been neither easy nor smooth but it has been interesting from many different perspectives. This paper gives an overview of this journey and discusses key lessons learned.

In the article the existing methods of developing a mobile Android application using the principles of CLean Architecture in order to optimize the architecture of software products at the start of the project are considered. The conceptual approaches and principles of Clean Architecture are studied, the possibility of building Android-applications according to the layered scheme according to which layers are connected by the Dependency Rule dependence rule is considered. The Android application “Lucky Days - Lunar Calendar” uses Android Studio based on the source code of the IntelliJ IDEA Community Edition product and the Kotlin programming language, which runs on top of the JVM and is compiled into JavaScript. The application codes for the I/O stream are shown, which demonstrates the use of the coroutine.In addition to the capabilities available in IntelliJ IDEA, Android Studio has implemented a new unified subsystem for building, testing, and deploying applications, which is based on Gradle tools and supports the use of continuous integration tools. The description of the program interface is given, the fragments of the codes responsible for the most important functions are resulted. It also includes advanced refactoring tools, compatibility checks with past releases, performance issues, memory usage monitoring, and usability assessment, tailored to the Android platform. A quick edit mode has also been added to the editor. To simplify the design of the application, we used the Android Navigation library from the Jetpack set and created a graph of connections between the application windows. A SQLite database was created and archived for the mobile application, and an EventBus with a set of functions was implemented to organize communication between unrelated parts of the application. Examples of Event-class and State-class codes used in the developed application are given. The proposed method of creating rational code that meets the principles of Clean Architecture, namely the separation of business logic from the display of list items is implemented for the development of Android-application.

This article presents a methodology to formalize the behavior of the machines composing a production line, and to automatically generate their virtual prototypes for efficient and correct plant simulation. The approach exploits assume-guarantee reasoning through contracts to model the interaction between the different components of a production line. The approach is guided by a well-known taxonomy of industrial machines and associated manufacturing processes to identify each elementary action related to a specific machine. Contracts enable to build executable models of all the machines available in the production line by using automatic synthesis. The generated models can be integrated into a state-of-the-practice industrial plant simulation software to estimate and validate the production line's behavior. The presentation of the methodology is supported by a running example based on a real production line, showing the step-by-step application of the approach to a concrete scenario.

This article presents approaches for performance improvements into two large and well-known open source projects, Git and GNU Compiler Collection, using parallel programming. We share the difficulties faced and the strategies used, concluding with a set of lessons learned that are useful to similar parallelization processes.

With the advancing digitisation of society and industry we observe a progressing blending of computational, physical, and social processes. The trustworthiness and sustainability of these systems will be vital for our society. However, engineering modern computing systems is complex as they have to: i) operate in uncertain and continuously changing environments, ii) deal with huge amounts of data, and iii) require seamless interaction with human operators. To that end, we argue that both systems and the way we engineer them must become smarter. With smarter we mean that systems and engineering processes adapt and evolve themselves through a perpetual process that continuously improves their capabilities and utility to deal with the uncertainties and amounts of data they face. We highlight key engineering areas: cyber-physical systems, self-adaptation, data-driven technologies, and visual analytics, and outline key challenges in each of them. From this, we propose a research agenda for the years to come.

This chapter describes the key components of the Advanced Manufacturing Cloud of Things (AMCoT) framework and depicts how to design and implement them by utilizing advanced information and communication technologies, such as cloud computing, edge computing, Internet of Things, big data analytics (BDA), and container technologies. The AMCoT framework consists of two parts: the cloud part and the factory part. The cloud part of the AMCoT framework contains the following five key components: web servers, manufacturing services automated construction scheme (MSACS), Docker and Kubernetes environment, containerized MSACS, and BDA application platform. The chapter presents the framework designs of cyber‐physical agent (CPA) and containerized CPA. It shows that the performance evaluation of the BDA application platform in processing big data. For storing and processing production‐related big data, the cloud part of the AMCoT framework contains a BDA application platform. The practitioners in manufacturing industries can refer to contents for building their desired intelligent manufacturing platforms.

To enhance the quality of teaching activities related to Engineering Design, reverse engineering activities were suggested to help students construct engineering design knowledge, especially identification and understanding of product functionalities by the immersion in the factual intricacies of existing products. However, the implementation of these activities presents many downsides as the use of reverse engineering processes in a linear and compartmentalized fashion. To make reverse engineering an integrative and effective learning activity, an accompanying visual tool canvas is proposed in this work. It communicates and develops a more holistic view of the features and solutions offered by the product studied. This reverse engineering canvas (RE Canvas) encompasses eight blocks that map the essential elements of the teardown activities and is intended to help students identify and understand functionalities of the product studied to turn them into new creations. To test the relevance of the RE canvas, an experimental test was carried out with our engineering students. Some results are illustrated to help understand its logic and rationale. Mainly, the canvas has enhanced the benefits of reverse engineering activity by making it more understandable, integrative, and inviting to both iteration and redesign. The proposed RE canvas is a contribution to the development of competency-empowering tools that strengthen the design skills of engineering students.

Software and systems improvement requests to merge various interpretations from several improvement models and techniques. A particular challenge is the multitude of models for requirements and quality, which can get time consuming and error prone to trace, change, and verify. Lately, Ontologies have been used across several domains and for numerous purposes to be applied for many applications. Besides, recent work in Artificial Intelligence is discovering the use of formal ontologies as a way of identifying content-specific agreements for the sharing and reuse of knowledge among software entities. Therefore, this paper describes how ontology engineering is used to construct an Ontological structure of the proposed SPI-CMMI framework –which based on using Six sigma approach integrated with CMMI-Dev model and Quality Function Deployment (QFD) technique- with its progressive phases, related activities, recommended tools and the CMMI-Dev 1.3 representation. The SPI-CMMI Ontology provides a shared improvement terminology, defines precise and unambiguous semantics for the software enterprises and enables reuse of improvement phase’s knowledge; in addition it makes domain assumptions explicit and separate domain knowledge from the operational knowledge.

O presente artigo difunde alguns dos resultados de uma investigação de doutorado com foco na Engenharia de Software Educativo. Discutimos no recorte aqui veiculado, os resultados da análise da engenharia do software Modellus e como esta contribuiu para (re)pensar os métodos e técnicas da Engenharia Didático-Informática. Assim, a pesquisa aqui apresentada está inserida na problemática de metodologias de desenvolvimento de software educativo bem como nas formas de construção de tecnologias digitais que auxiliem, efetivamente, as atividades de ensinar e aprender. Os procedimentos metodológicos foram iniciados com um levantamento bibliográfico a fim de atualizar os referenciais e posteriormente a construção de uma entrevista para obter informações precisas sobre a construção do software Modellus. Os resultados deste estudo indicam que: 1. É possível classificar a engenharia a qual o Modellus foi submetido como "Didático-Informática" e 2. a Engenharia Didático-Informática se configura como uma metodologia robusta para o desenvolvimento de software educativo que alie contribuições teóricas e metodológicas oriundas da Engenharia Didática e da Engenharia de Software.

Today we live a high increasing digitalization in industry 4.0. As part of the evolution of CAD solutions on the market, there is a particular interest in new generation software which are distributed as Software-as-a- Service (SaaS) such as Onshape, 3D Experience, Fusion 360, etc. In order to prepare engineering students for integrating such software within the Université de Technologie de Compiègne (UTC), a further practicing study is carried out in this paper. This study aims to identify, analyze, experiment, evaluate and compare the capacities of Cloud-based CAD solutions on the market and in scientific research work in order to define potential benefits for their implementation in mechanical engineering education. Therefore, we tested two use scenarios of the two Cloud-based software; Onshape and Fusion 360 on a case study. Then, we discussed the comparison results.

A future-state architectural strategy designed to support chatbot integration with service delivery systems.

Software architectural designs are usually changed over time to support emerging technologies and to adhere to new principles. Architectural migration is an important activity that helps to transform the architectural styles applied during a system’s design with the result of modernising the system. If not performed correctly, this process could lead to potential system failures. This article presents an automated approach to refactoring architectural design and to planning the evolution process. With our solution, the architectural design can be refactored, ensuring that system functionality is preserved. Furthermore, the architectural migration process allows the system to be safely and incrementally transformed. We have evaluated our approach with five real-world software applications. The results prove the effectiveness of our approach and identify factors that impact the performance of architectural verification and migration planning. An interesting finding is that planning algorithms generate migration plans that differ in term of their relative efficiency.

This paper presents a Sensing-as-a-Service run-time Service Oriented Architecture (SOA), called 3SOA, for the development of Internet of Things (IoT) applications. 3SOA aims to allow interoperability among various IoT platforms and support service-oriented modelling at high levels of abstraction where fundamental SOA theories and techniques are fully integrated into a practical software engineering approach. 3SOA abstracts the dependencies of the middleware programming model from the application logic. This abstraction allows the development efforts to focus on writing the application logic independently from hardware platforms, middleware, and languages in which applications are programmed. To achieve this result, IoT objects are treated as independent entities that may interact with each other using a well-defined message exchange sequence. Each object is defined by the services it provides and the coordination protocol it supports. Objects are then able to coordinate their resources to address the global objectives of the system. To practically validate our proposals, we demonstrate an intelligent transportation system and data privacy functional prototypes as proof of concepts. The use cases show that 3SOA and the presented abstraction language allow the amalgamation of macroprogramming and node-centric programming to develop real-time and efficient applications over IoT.

The discipline of reverse engineering integrated circuits (ICs) is as old as the technology itself. It grew out of the need to analyze competitor’s products and detect possible IP infringements. In recent years, the growing hardware Trojan threat motivated a fresh research interest in the topic. The process of IC reverse engineering comprises two steps: netlist extraction and specification discovery. While the process of netlist extraction is rather well understood and established techniques exist throughout the industry, specification discovery still presents researchers with a plurality of open questions. It therefore remains of particular interest to the scientific community. In this paper, we present a survey of the state of the art in IC reverse engineering while focusing on the specification discovery phase. Furthermore, we list noteworthy existing works on methods and algorithms in the area and discuss open challenges as well as unanswered questions. Therefore, we observe that the state of research on algorithmic methods for specification discovery suffers from the lack of a uniform evaluation approach. We point out the urgent need to develop common research infrastructure, benchmarks, and evaluation metrics.

With the widespread use of computers, in the design world, rule-based design methods, which can work in harmony with computer logic and can be easily adapted to the computer environment, have come to the fore. It is possible to analyze the logic of a design made with the rule-based design method. It is even possible to change the design which is placed on the rule base by removing the rules, in the computer environment, or creating new designs with the same design logic. In this paper, a new hybrid model is proposed based on Interval Type-2 Fuzzy Analytic Network Process (IT2 FANP) and Interval Type-2 Fuzzy TOPSIS (IT2 Fuzzy TOPSIS) for the evaluation of store plan alternatives produced with rule-based design method. The IT2 FANP method is used to determine the weight of criteria determined by experts in the selection of store plan alternatives. Then, the IT2 Fuzzy TOPSIS method is used to obtain the ranking of alternatives with Interval Type-2 trapezoidal fuzzy numbers. The originality of the paper comes from the first-time usage of a hybrid approach based on IT2 FANP and IT2 Fuzzy TOPSIS methodology in the prioritizing of store plan alternatives produced with rule-based design method.

Financiado para publicación en acceso aberto: Universidade da Coruña/CISUG [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. Xunta de Galicia; IN852A 2018/14 Xunta de Galicia; ED431G 2019/01 This work has been partially funded by grants: MICIU/FEDER-UE, MAGIST: PID2019-105221RB-C41; MICIU/FEDER-UEBIZDEVOPSGLOBAL: RTI-2018-098309-B-C32, Xunta de Galicia/FEDER-UE, ConectaPeme, GEMA: IN852A 2018/14; MINECOAEI/FEDER-UE Datos 4.0: TIN2016-78011-C4-1-R; MINECOAEI/FEDER-UE Velocity: TIN2016-77158-C4-3-R; CITIC research center funded by XUNTA and EU through the European Regional Development Fund- Galicia 2014-2020 Program, grant ED431G 2019/01. Funding for open access charge: Universidade da Coruña/CISUG.

Software applications in educational technology have been a strong driving force for the success of online learning at all levels. These applications are created for various purposes and are used by a range of experts. The development of a successful educational technology software takes a deliberate team effort and thoughtful project management. This interpretive case study details the processes, successes, and challenges determined throughout the development of an educational web application, the Social Performance Optimization Tool (SPOT). In describing the evolution of SPOT, and the processes the heterogeneous team followed in the development of the web application, this study provides analysis and guidance to educational researchers who are interested in developing educational web applications in the future. The study described how authors mindfully adopted software design models, team management techniques, and communication tools. Additionally, the paper highlights practical and unique implications developers must account for when working in higher education contexts.