We present an experience report on an industrial feasibility study that evaluates the application of code LLM technologies within an organization, ensuring that no data leaves the firm’s perimeter. To address a set of feasibility questions, we employed state-of-the-art techniques, including Low-Rank Adaptation (LoRA), Parameter-Efficient Fine-Tuning (PEFT), and 4-bit quantization, to develop a pipeline for creating a fine-tuned version of an existing code LLM that is small enough to allow both training and inference on commodity hardware, thereby eliminating the need for cloud-based solutions that would expose sensitive assets, such as parts of the existing code base, outside the firm’s local network. We evaluated the pipeline on a general programming language (namely Python) to assess its performance, and our results show that it is adequate for the task at hand. Other than concerns about data privacy, another motivation for this study stems from the firm’s adoption of a domain-specific programming language, which is not directly supported by most existing code LLMs. However, we believe that the lessons we learned in this experience could be valuable in many other contexts where a firm is evaluating the feasibility of an in-house AI-based solution rather than depending on external service providers.

We conduct an exploratory, large-scale, longitudinal study of 50 years of commits to publicly available version control system repositories, in order to characterize the geographic diversity of contributors to public code and its evolution over time. We analyze in total 2.2 billion commits collected by Software Heritage from 160 million projects and authored by 43 million authors during the 1971--2021 time period. We geolocate developers to 12 world regions derived from the United Nation geoscheme, using as signals email top-level domains, author names compared with names distributions around the world, and UTC offsets mined from commit metadata.

In recent years, new classes of highly dynamic, complex systems are gaining momentum. These classes include, but are not limited to IoT, smart cities, cyber-physical systems and sensor networks. These systems are characterized by the need to express behaviors driven by external and/or internal changes, i.e. they are reactive and context-aware. A desirable design feature of these systems is the ability of adapting their behavior to environment changes. In this paper, we propose an approach to support adaptive, reactive systems based on semantic runtime representations of their context, enabling the selection of equivalent behaviors, i.e. behaviors that have the same effect on the environment. The context representation and the related knowledge are managed by an engine designed according to a reference architecture and programmable through a declarative definition of sensors and actuators. The knowledge base of sensors and actuators (hosted by an RDF triplestore) is bound to the real world by grounding semantic elements to physical devices via REST APIs. The proposed architecture along with the defined ontology tries to address the main problems of dynamically re-configurable systems by exploiting a declarative, queryable approach to enable runtime reconfiguration with the help of (a) semantics to support discovery in heterogeneous environment, (b) composition logic to define alternative behaviors for variation points, (c) bi-causal connection life-cycle to avoid dangling links with the external environment. The proposal is validated in a case study aimed at designing an edge node for smart buildings dedicated to cultural heritage preservation.

IoT, smart cities, cyber-physical systems and sensor networks are context-aware, highly dynamic and reactive systems.Their implementation should take into account the heterogeneity of their components and make easy the management of events unplanned at design time.According to these requirements, in this paper we propose an ontology-based approach to provide runtime models of the physical entities characterizing context-aware reactive systems.We extend SSN, a W3C standard ontology, to support complex reactive behaviors through the modeling of Logical Sensors and Actuators (LSA ontology); we also present a software architecture in which a knowledge base, structured coherently with this semantic model, is bound to real world entities by grounding (via web services) semantic elements to physical sensors and actuators.To validate the approach we discuss a case study related to smart buildings for cultural heritage preservation.

Software-intensive systems work in ever-changing environments requiring expensive technical efforts to manage their evolution. In order to mitigate their risks and costs they should dynamically self-adapt to any modification of their environment. MAPE-K (Monitor, Analyze, Plan, Execute - Knowledge) is the basic architectural pattern for building software-intensive self-adaptable systems. In this paper we propose an approach in which all the information about a system and its environment is unified by using Semantic Web technologies into a set of semantic run-time models which enhance the Knowledge in MAPE-K. Ontologies are used to manage the interaction and integration of these models with disparate data sources. The resulting knowledge base is then used to drive adaptation activities exploiting well known languages and notations. We discuss how MAPE-K can be exploited in order to take advantage of ontological representations, along with Semantic Web languages and tools, by studying a real-word case study: a legacy system that was not designed to perform automatic adaptation. We discuss merits and limits of our approach based on semantic run-time models both in the context of this specific case study and in a broader scope.

Background Software systems are relying more and more on multi-core hardware requiring a parallel approach to address the problems and improve performances. Unfortunately, parallel development is error prone and many developers are not very experienced with this paradigm also because identifying, reproducing, and fixing bugs is often difficult. Objective The main goal of this paper is the identification of an approach able to: (i) identify solved concurrency-related bugs to characterize them and help retrospective activities; (ii) identify concurrency-related bugs as soon as they are entered in the bug management system to support bug triage phase and allocate them to more experienced developers. Approach To this end, the paper analyzes bugs related to concurrency looking at their specific characteristics using different machine learning methods to automatically distinguish them from other kinds of bugs based on the data available in the issue tracking systems and in the code repositories. Results The overall best models we developed for Apache HTTP Server and MariaDB have a precision of 0.985 and 0.814 and a recall of 0.876 and 0.629 when considering linked bugs (bug reports information in bug repository and the corresponding fix in the version control system) and a precision of 0.978 and 0.779 and a recall of 0.889 and 0.569 when considering only the information from bug reports. Conclusions Such results allow the development of an automated system able to classify such bugs and support developers in the bug triage process.

Today's software systems increasingly work in changing environments, where rapid modifications in user needs, resource variabilities and system faults require remarkable administrative efforts. In order to mitigate the costs for governing these activities, software systems are expected to dynamically self-adapt. The problem of supporting auto-adaptation, which is complex activity in itself, is further exacerbated when applied to legacy systems which have not been developed for this purpose. In this paper we introduce a novel approach to self-adaptation based on the MAPE-K paradigm, where semantic models are used to provide an unified view of the heterogeneous elements composing these systems, and reasoning mechanisms are leveraged to drive adaptation strategies. We present the implementation of an adaptation engine based these concepts that uses ontologies and Semantic Web technologies, and discuss its application in a real world case study. From this experience, we offer recommendations for future research in this area.

KnowBest is a system that has been designed to support recording/replaying/sharing best practices involving social software tools in an emergent coordination context. One of the main components of the system is a semantic wiki that, through the social management of content and its associated annotations, makes available semantically-enriched information that can be machine processed and exploited and reasoned upon allowing the development of inference-based applications. In order for this class of applications to be effective, the structure of the semantic knowledge is of fundamental importance. Not always, in fact, the use of pre-defined, accurately designed ontologies is possible (which is mostly true for wikis where not just the knowledge but also its structure is synthesized from social interactions). In this paper we show how it is possible to effectively support emergent ways of organizing knowledge with a two-layers approach in which a pre-defined core structure can be freely extended with domain-related concepts by exploiting semantic wikis' editing facilities, we apply this approach in the implementation of KnowBest's recommender, a component designed to leverage semantic inference in order to provide suggestions about existing best practices to the users in a way that is similar to what a car navigation system does for car drivers.

This special issue of Software: Practice and Experience contains extended versions of the best papers accepted for the Web Technologies (WT) track of the 25th ACM Symposium on Applied Computing (SAC), which was held in Taichung, Taiwan in March 2011. In recent years the WT track has attracted an increasing number of high-quality contributions on everything web, by researchers and practitioners from both industry and academia. Because of the nature of the Web, the applied research on these topics has the distinctive potential of leading to tangible changes in our everyday experience in a very short time frame. We are honored to have been able to witness such evolution serving as track chairs for the last 4 years, and we hope to give you a representative glimpse of it with the articles contained in this special issue. In 2011, the WT track has received 31 submissions from 19 countries and accepted ten full papers (for an acceptance rate of about 32%). In addition to that, three submissions have been presented as posters on-site, during the SAC conference. We have selected four among the best papers of the 2011 edition, with a focus on recent evolution of the World Wide Web as an everyday and for everyone platform. Given its focus on the dissemination of tangible software experiences, Software: Practice and Experience is a perfect match for both the research topics and the mixed academic/practitioner approach of the WT track of ACM SAC. We are therefore confident to meet your interests, and we would like to wish you a very good read!

The importance of testing has recently seen a significant growth, thanks to its benefits to software design (e.g. think of test-driven development), implementation and maintenance support. As a consequence of this, nowadays it is quite common to introduce a test suite into an existing system, which was not designed for it. The software engineer must then decide whether using tools which automatically generate unit tests (test suites necessary foundations) and how. This paper tries to deal with the issue of choosing the best approach. We will describe how different generation techniques (both manual and automatic) have been applied to a real case study. We will compare achieved results using several metrics in order to identify different approaches benefits and shortcomings. We will conclude showing the measure how the adoption of tools for automatic test creation can shift the trade-off between time and quality.

Process driven software architectures are establishing themselves as prominent examples of distributed software infrastructures. Workflow Management Systems, web service orchestration platforms, Business Process Management support systems are relevant instances of process driven software architectures all of which, as the name suggests, are characterized as having a process perspective. In this paper we show that a (well designed) process modeling language and its execution engine can address the process perspective in different architectures and be (re)used among different application domains resulting in useful tools for the design and the implementation of process-driven applications. This can be achieved by maximizing the suitability of such a language via high expressive power and good separation of concerns. We also show sample process driven architectures, addressing different application domains, that are built with it.

In this paper, we discuss the design, implementation, and experimental evaluation of a middleware architecture for enabling service level agreement (SLA)-driven clustering of QoS-aware application servers. Our middleware architecture supports application server technologies with dynamic resource management: application servers can dynamically change the amount of clustered resources assigned to hosted applications on-demand so as to meet application-level quality of service (QoS) requirements. These requirements can include timeliness, availability, and high throughput and are specified in SLAs. A prototype of our architecture has been implemented using the open-source J2EE application server JBoss. The evaluation of this prototype shows that our approach makes possible JBoss' resource usage optimization and allows JBoss to effectively meet the QoS requirements of the applications it hosts, i.e., to honor the SLAs of those applications

This paper introduces an experimental evaluation of a set of middleware services we have developed in order to enable application server technology to meet such quality of service (QoS) application requirements as service availability, timeliness and throughput. These services, developed in the context of the EU funded project TAPAS, have been integrated in the open source JBoss application server, and are publicly available

In the linking model of the World Wide Web each link is stored in the referring document within an attribute of the A tag. All the hyperlink defined this way can reference a single resource or a single fragment. With the evolution of Web technologies more powerful linking languages (XLink and XPointer) have been proposed.Here we introduce XLinkProxy, a Web application that allows sophisticated hyperlink (defined using XLink and XPointer) to be defined outside referring documents, giving users the chance to build dynamic multidestination, multidirectional links databases.

In this paper we describe an experience in designing a groupware application distributed over the WWW to solve a conference management problem. The system we design coordinates the activities of several people engaged in reviewing and selecting papers submitted for a scientific conference. We discuss why such an application is interesting and describe how we designed it. The architecture we suggest implements what we call an active Web, because it includes entities which we are able to use and provide services offered through WWW infrastructures. Users, agents, and active documents can interoperate using a set of basic services for communication and synchronization. The active Web infrastructure we describe here is based on coordination technology integrated with Java.

The original Web did not support multiuser, interactive applications. This shortcoming is being studied, and several approaches have been proposed to use the Web as a platform for programming Internet applications. However, most existing approaches are oriented to centralized applications at servers, or local programs within clients. To overcome this deficit, we introduce PageSpace, that is a reference architecture for designing interactive multiagent applications. We describe how we control agents in PageSpace, using variants of the coordination language Linda to guide their interactions. Coordination technology is integrated with the standard Web technology and the programming language Java. Several kinds of agents live in the PageSpace: user interface agents, personal homeagents, agents that implement applications, and agents which interoperate with legacy systems. Within our architecture, it is possible to support fault-tolerance and mobile agents as well.

Currently, the Web does not support distributed applications well. Existing approaches are oriented towards centralized applications at servers, or local programs within clients. To overcome this deficit, the PageSpace platform was designed for distributed, coordinated agents in the Web. We take a specific approach to coordinate agents in PageSpace applications, namely variants of coordination language Linda that support rules and services to guide their cooperation. This technology is integrated with the standard Web technology and the language Java. Several kinds of agents live in the PageSpace: user interface agents, personal home agents, the agents that implement applications, and the kernel agents of the platform. Within the architecture it is possible to support fault tolerance and mobile agents as well.