The ability of Generative AI (GAI) technology to automatically check, synthesize, and modify software engineering artifacts promises to revolutionize all aspects of software engineering. Using GAI for software engineering tasks is consequently one of the most rapidly expanding fields of software engineering research, with over a hundred LLM-based code models having been published since 2021. However, the overwhelming majority of existing code models share a major weakness—they are exclusively trained on the syntactic facet of software, significantly lowering their trustworthiness in tasks dependent on software semantics. To address this problem, a new class of “Morescient” GAI is needed that is “aware” of (i.e., trained on) both the semantic and static facets of software. This, in turn, will require a new generation of software observation platforms capable of generating large quantities of execution observations in a structured and readily analyzable way. In this article, we present a vision and roadmap for how such “Morescient” GAI models can be engineered, evolved, and disseminated according to the principles of open science.

A core principle of open science is the clear, concise and accessible publication of empirical data, including “raw” observational data as well as processed results. However, in empirical software engineering there are no established standards (de jure or de facto) for representing and “opening” observations collected in test-driven software experiments — that is, experiments involving the execution of software subjects in controlled scenarios. Execution data is therefore usually represented in ad hoc ways, often making it abstruse and difficult to access without significant manual effort. In this paper we present new data structures designed to address this problem by clearly defining, correlating and representing the stimuli and responses used to execute software subjects in test-driven experiments. To demonstrate their utility, we show how they can be used to promote the repetition, replication and reproduction of experimental evaluations of AI-based code completion tools. We also show how the proposed data structures facilitate the incremental expansion of execution data sets, and thus promote their repurposing for new experiments addressing new research questions.

Given the abundance of software in open source repositories, code search engines are increasingly turning to “big data” technologies such as natural language processing and machine learning, to deliver more useful search results. However, like the syntax-based approaches traditionally used to analyze and compare code in the first generation of code search engines, big data technologies are essentially static analysis processes. When dynamic properties of software, such as run-time behavior (i.e., semantics) and performance, are among the search criteria, the exclusive use of static algorithms has a significant negative impact on the precision and recall of the search results as well as other key usability factors such as ranking quality. Therefore, to address these weaknesses and provide a more reliable and usable service, the next generation of code search engines needs to complement static code analysis techniques with equally large-scale, dynamic analysis techniques based on its execution and observation. In this paper we describe a new software platform specifically developed to achieve this by simplifying and largely automating the dynamic analysis (i.e., observation) of code at a large scale. We show how this platform can combine dynamically observed properties of code modules with static properties to improve the quality and usability of code search results.

In projection-based modeling environments, users work with views of the modelled system or enterprise that are generated dynamically, on demand, from a Single Underling Model (SUM). Moreover, they usually cannot change the SUM directly, but can only influence its contents indirectly via views. This means that at least some of the views need to be editable so that they can be used to evolve the SUM to a new state. However, this is not always possible when the transformations used to project SUM content into view content do not provide the information needed to unambiguously map view changes into SUM changes. Therefore, mechanisms are needed to identify and take appropriate measures to ensure that the integrity of the SUM is not comprised, and it is not updated in unintended ways, when insufficient information is available. This paper illuminates the basic nature of the problem, categorizes the different kinds of situations in which editing ambiguities can arise and discusses potential strategies for dealing with them. These techniques contribute to the creation of user-friendly, yet dependable, projection-based modeling environments.

Multi-view environments provide different views of software systems optimized for different stakeholders. One way of ensuring consistency of overlapping and inter-dependent information contained in such views is to project them “on demand” from a Single Underlying Model (SUM). However, there are various ways of building and evolving such SUMs. This paper presents criteria to distinguish them, describes three archetypical approaches for building SUMs, and analyzes their advantages and disadvantages. From these criteria, guidelines for choosing which approach to use in specific application areas are derived.

o validate hypotheses and tools that depend on the semantics of software, it is necessary to assemble, prepare and maintain (i.e. curate) large, high-quality corpora of executable software systems exhibiting certain desired behavior and/or properties. Today this is a highly tedious and laborious activity requiring significant human time and effort. In this paper we therefore present a prototype platform that supports the notion of “live data sets” where almost all aspects of the data set curation process are automated. Instead of curating data sets by hand, or writing dedicated tools to select and check software samples on a case-by-case basis, a live data set allows users to simply describe their requirements as abstract scripts written in a declarative domain specific language. After explaining the approach and the key ideas behind its implementation, in this paper we present two examples of executable corpora generated automatically from a live data set populated from Maven Central. The first illustrates a “semantics agnostic” use case where the actual behavior of the software is unimportant, while the second illustrates a “semantics specific” use case where software implementing a specific functional abstraction is selected.

Since it was first proposed in 1992 under the name of "behavior sampling", the idea of judging whether software systems are functionally equivalent by observing their responses to common stimuli (i.e. tests) has been used for a range of tasks such as software retrieval, functional redundancy measurement and semantic clone detection. However, its efficacy has only been studied in one small experiment, with limited generalizability, described in the original paper proposing the approach. The results of that experiment suggest that a relatively small number of randomly generated tests (i.e. 4) is sufficient to recognize non-functional-equivalent software 85% of the time. This number has therefore been adopted as "sufficient" in numerous applications of the approach. In this paper we present a much larger study which suggests at least 39 randomly generated tests are actually needed to achieve this level of effectiveness, but that a far fewer number of tests generated using coverage-based heuristics are sufficient. Since these results are much more generalizable, they have implications for future applications of behavioral sampling for dynamic behavior comparison.

Most view-based modelling approaches are today based on a "synthetic" approach in which the views hold all the information modelled about a system and are kept consistent using explicit, inter-view correspondence rules. The alternative "projective" approach, in which the contents of views are "projected" from a single underlying model on demand, is far less widely used due to the lack of suitable conceptual frameworks and languages. In this paper we take a step towards addressing this problem by presenting the foundations of a suitable language and conceptual framework for defining and applying views for projective modelling. The framework leverages deep modeling in order to seamlessly support views that exist at, and span, multiple levels of classification. The viewpoint language was developed in the context of Orthographic Software Modelling (OSM) but is more generally applicable to any projective modelling approach.

All Enterprise Architecture Modeling (EAM) approaches revolve around the use of multiple, inter-related views to describe the properties of a system and its surrounding environment -- that is, they are multi-view specification (MVS) approaches. However, there is still little consensus on how such modeling environments should be realized and on the pros and cons of the different fundamental design choices involved in building them. In this paper we identify the different design choices put forward in the literature, evaluate their mutual compatibility, and discuss the extent to which they scale up to large enterprise systems. Finally we present some additional choices and outline some of the key features that future multi-view modeling environments should ideally support.

Capturing relationships between concepts in a domain is as important as capturing the concepts themselves. Modeling languages reflect this by providing connections with rich semantics, such as associations and links, thus providing a key advantage over approaches that support relationships with simple references only. While connections for two-level modeling (e.g. in the UML) have enjoyed a stable design for a considerable time, the same cannot be said for connections in multi-level modeling languages. As interest in multi-level modeling grows, it is important to provide a comprehensive design for connections that not only adheres to multi-level principles such as level-agnosticism and explicit level organization, but also supports deep characterization, i.e., the ability to specify level content beyond one level boundary. In this paper we propose a unifying conceptual model for connections whose expressiveness and scalability does not come at the cost of concept proliferation.

The first generation of software search engines such as Merobase, Sourcerer etc. Showed that it is possible to support reasonably sophisticated searches over large bodies of software components using indices based on full-text search engines (most commonly Lucene). However, the "tricks" these engines use to map code structure to flat text are not only inflexible, they do not scale well to components composed of multiple program modules (e.g. Interfaces, classes etc.) As a result, beyond plain string matching, they are only able to support a limited and a priori fixed set of query types, and are rarely, if ever able, to find components composed of more than one code module. In this paper we present an index representation approach which is able to support the key information bound up in source code in a more accurate, flexible way, and thus efficiently support a much wider range of searches on components composed of multiple program modules.

As the number and diversity of technologies involved in building enterprise systems continues to grow so does the importance of modeling tools that are able to present customized views of enterprise systems to different stakeholders according to their needs and skills. Moreover, since the range of required view types is continuously evolving, it must be possible to extend and enhance the languages and services offered by such tools on an ongoing basis. However, this can be difficult with today's modeling tools because the meta-models that define the languages, views and services they support are usually hardwired and thus not amenable to extension. In practice, therefore, various workarounds have to be used to extend a tool's underlying meta-model. Some of these are built into the implemented modeling standards (e.g. the UML profile, BPMN 2.0 and ArchiMate 2.0 extension mechanisms) while others have to be applied by complementary, external tools (e.g. model weaving). These techniques not only increase accidental complexity, they also reduce the ability of the modeling tool to ensure adherence to enterprise rules and constraints. In this paper we discuss the strengths and weaknesses of the various approaches for language extension and propose a modeling framework best able to support the main extension use-cases currently found in practice today.

This paper describes a large, unabridged data-set of Java source code gathered and shared as part of the Merobase Component Finder project of the Software-Engineering Group at the University of Mannheim. It consists of the complete index used to drive the search engine, www.merobase.com, the vast majority1of the source code modules accessible through it, and a tool that enables researchers to efficiently browse the collected data. We describe the techniques used to collect, format and store the data set, as well as the core capabilities of the Merobase search engine such as classic keyword-based, interface-based and test-driven search. This data-set, which represents one of the largest searchable collections of source and binary modules available online, has been recently made available for download and use in further research projects. All files are available at http://merobase.informatik.uni-mannheim.de/sources/.

Domain-Specific Modeling Languages (DSMLs) have received great attention in recent years and are expected to play a big role in the future of software engineering as processes become more view-centric. However, they are a “two-edged sword”. While they provide strong support for communication within communities, allowing experts to express themselves using concepts tailored to their exact needs, they are a poor vehicle for communication across communities because of their lack of common, transcending concepts. In contrast, General-Purpose Modeling Languages (GPMLs) have the opposite problem - they are poor at the former but good at the latter. The value of models in software engineering would therefore be significantly boosted if the advantages of DSMLs and GPMLs could be combined and models could be viewed in a domain-specific or general-purpose way depending on the needs of the user. In this paper we present an approach for achieving such a synergy based on the orthogonal classification architecture. In this architecture model elements have two classifiers: a linguistic one representing their “general-purpose” and an ontological one representing their “domain-specific” type. By associating visualization symbols with both classifiers it is possible to support two concrete syntaxes at the same time and allow the domain-specific and general-purpose notation to support each other - that is, to form a symbiotic relationship.

The prime obstacle to automated defect testing has always been the generation of "correct" results against which to judge the behavior of the system under test - the "oracle problem". So called "back-to-back" testing techniques that exploit the availability of multiple versions of a system to solve the oracle problem have mainly been restricted to very special, safety critical domains such as military and space applications since it is so expensive to manually develop the additional versions. However, a new generation of software search engines that can find multiple copies of software components at virtually zero cost promise to change this situation. They make it economically feasible to use the knowledge locked in reusable software components to dramatically improve the efficiency of the software testing process. In this paper we outline the basic ingredients of such an approach.

Today's testing technologies and tools are all essentially based on the assumption that testers have full, unlimited access to systems under test along with the actual and expected results of test executions. This reflects the fact that, historically, software systems were usually developed by a single organization using components completely under its own control, and were tested in isolation under carefully controlled, "offline" conditions. However, with the rise of service-oriented architectures and the drive for more software reuse, these conditions are changing and the assumption that testers must be given full, trusted access to systems under test is no longer universally valid. In this paper we make the case for a new form of testing -- penurious testing -- in which testers do not have full, trusted access to the entities they test. By means of small examples we motivate its use and describe a language and framework that supports this new form of testing.

Given the projected growth in IT over the coming decades it is important that the supply of, and demand for, computing services be made as environmentally friendly as possible. One of the key technologies for achieving this will undoubtedly be cloud computing which opens up many new opportunities for streamlining the way computing services are delivered and used. Several research projects have therefore recently started to examine ways of improving the efficiency of cloud computing infrastructures and of understanding the energy efficiency of computing algorithms. However, to date these have mainly focused on increasing the efficiency of cloud computing services at the relatively low "platform" and "infrastructure" levels of abstraction at which they are typically offered today. In this paper we argue that to maximize the environmental benefits of cloud computing, both from the demand as well as the supply point of view, it is necessary to raise the level of abstraction at which cloud services are delivered and consumed. To this end, we introduce the vision of "Modelling as a Service (MaaS)" and explain how it provides an essential foundation for reducing the environmental impact of computing services.

In this paper we propose a typed approach to business process specification based on typed workflow charts. These can be exploited as a domain-specific programming language and facilitate tight integration between workflow definition and system dialogue programming. The approach also supports the integration of business process modeling and business process automation. We discuss two ways of exploiting this potential for integration, one is the design of an integrated business process management suite and the other is a software artifact tracker based on a view-based, multi-dimensional software modeling tool.

As software services become the dominant platform for enterprise computing and B2B/B2C applications, testing their correctness and dependability assumes ever more importance. However, unlike the languages used to define and realize them, the languages used to test service-based systems have changed little over recent years. Today, tests for services and service-oriented architectures are still typically written using approaches such as xUnit or Testing and Test Control Notation (TTCN-3) developed for traditional software. While programmatic approaches allow the full power of object-oriented programming to be used to define tests, they are only intelligible to IT experts. Model-based test representation techniques such as the Unified Modeling Language (UML) testing profile and the TTCN-3 visualization features are understandable by more stakeholders but provide only partial descriptions of tests and do not scale well beyond simple algorithms. In this paper we present a new approach to software service testing which combines the expressive power of tabular tests specification techniques like Framework for Integrated Test (FIT) with programmatic techniques like xUnit and TTCN-3. The new approach also integrates test definition with test result specification and evaluation. This allows non-IT experts to define and run tests and integrates testing more tightly into the service-oriented development process.

As its success has demonstrated, the principles of service-oriented architectures yield significant benefits for the integration, maintenance and administration of complex enterprise computing systems. However, they are primarily oriented towards the needs of server-side system integrators rather than the developers of client applications and business processes. In particular, the absence of the notion of types, in the sense of abstract data types and object-oriented programming, limits the way in which client and process developers can access resources in a service-oriented architecture and leverage reusable assets. This is additionally aggravated by the confusion surrounding the notion of state and the question of whether services should in general be stateful or stateless. In this paper we address these problems by introducing a client-oriented model of Web services in service-oriented development that provides a flexible notion of types and instances, and distinguishes between client-oriented and implementation-oriented notions of service state. We also introduce the concept of congregation as a new role in service-oriented development designed to support the new type model and discuss how it can be implemented in the light of the proposed state model using Web services as the underlying technology.

The reuse of services in service-oriented development has in general not reached the levels that were expected when Web services technologies were introduced. There are several reasons why this is the case including the lack of efficient service discovery mechanisms and also the low number of available services within service registries. However, the potential for reuse in service-oriented development is in general significantly increased, if besides already deployed Web services, also the regular software components available on the internet or within enterprises are considered as potential sources of services. To use these software components as services a mechanism is needed that systematically deploys and manages the associated assets and automatically makes them available for use by client applications. In this paper we will therefore introduce a new approach - called congregation - that supports the reuse of arbitrary software components by automatically deploying them as Web services for invocation by client applications and business processes in service-oriented software development.

Although domain-specific modeling tools have come a long way since the modern era of model-driven development started in the early 1990s and now offer an impressive range of features, there is still significant room for enhancing the flexibility they offer to end users and for combining the advantages of domain-specific and general-purpose languages. To do this, however, it is necessary to enhance the way in which the current generation of tools view metamodeling and support the representation of the multiple, ?ontological? classification levels that often exist in subject domains. State-of-the-art tools essentially allow users to describe the abstract and concrete syntaxes of a language in the form of metamodels and to make statements in that language in the form of models. These statements typically convey information in terms of types and instances in the domain (e.g., the classes and objects of UML), but not in terms of types of types (i.e., domain metaclasses), and types of types of types, and so on, across multiple classification levels. In essence, therefore, while they provide rich support for ?linguistic? metamodeling, the current generation of tools provides little if any built-in support for modeling ?ontological? classification across more than one type/instance level in the subject domain. In this paper, we describe a prototype implementation of a new kind of modeling infrastructure that, by providing built-in support for multiple ontological as well as linguistic classification levels, offers various advantages over existing language engineering approaches and tools. These include the ability to view a single model from the perspective of both a general-purpose and a domain-specific modeling language, the ability to define constraints across multiple ontological classification levels, and the ability to tie the rendering of model elements to ontological as well as linguistic types over multiple classification levels. After first outlining the key conceptual ingredients of this new infrastructure and presenting the main elements of our current realization, we show these benefits through two small examples.

The distribution of software engineering tasks is becoming ever more common. Requirements engineering, as the most critical phase, therefore requires methods and tools to support distributed teams. However, nearly all requirements engineering methods have originally been designed for collocated scenarios. Before applying these methods in distributed settings in practice and for scientific rigor, proper evaluation has to be conducted. Hence, we developed a methodologically sound and cost-effective evaluation method for distributed requirements engineering methods as well as the corresponding tool infrastructure for conducting evaluation projects.

One of the fundamental pillars of the Web service vision is a brokerage system that enables services to be published to a searchable repository and later retrieved by potential users. This is the basic motivation for the UDDI standard, one of the three standards underpinning current Web service technology. However, this aspect of the technology has been the least successful, and the few Web sites that today attempt to provide a Web service brokerage facility do so using a simple cataloguing approach rather than UDDI. In this paper we analyze why the brokerage aspect of the Web service vision has proven so difficult to realize in practice and outline the technical difficulties involved in setting up and maintaining useful repositories of Web services. We then describe a pragmatic approach to web service brokerage based on automated indexing and discuss the required technological foundations. We also suggest some ideas for improving the existing standards to better support this approach and Web service searching in general.

Runtime testing is important for improving the quality of software systems. This fact holds true especially for systems which cannot be completely assembled at development time, such as mobile or ad-hoc systems. The concepts of built-in-test (BIT) can be used to cope with runtime testing, but to our knowledge there does not exist an implemented infrastructure for BIT. The MORABIT project realizes such an infrastructure and extends the BIT concepts to allow for a smooth integration of the testing process and the original business functionality execution. In this paper the requirements on the infrastructure and our solution are presented

Today component- and service-based technologies play a central role in many aspects of enterprise computing. However, although the technologies used to define, implement, and assemble components have improved significantly over recent years, techniques for verifying systems created from them have changed very little. The correctness and reliability of component-based systems are still usually checked using the traditional testing techniques that were in use before components and services became widespread, and the associated costs and overheads still remain high. This paper presents an approach which addresses this problem by making the system verification process more component-oriented. Based on the notion of built-in tests - tests that are packaged and distributed with prefabricated, off-the-shelf components - the approach and supporting infrastructure help to automate some of the testing process, thereby significantly reduces system testing effort. After providing an introduction to the principles behind component-based verification, and explaining the main features of the approach, we show by means of a small example how it can reduce system verification effort

Reliability testing is of even greater importance in component-based development than it is in traditional development methods, since it is the only practical way of measuring how well assembled components match each others' expectations. However, support for reliability testing has improved little over the last few years and it remains one of the most costly elements of software engineering. In this paper we present an approach that tackles the most fundamental obstacle to more efficient reliability testing - namely, the problem of automating the generation of "correct" reference results against which to evaluate component outputs. The approach employs the same basic technologies that can be used to discover components for reuse, but instead of building them into the final system it uses them, in combination with others, as an automated pseudo-oracle for measuring the reliability of self-built components. This significantly enhances the utility of component discovery technology, since it allows value to be derived from components which do not pass the threshold needed for full reuse but are sufficiently reliable to form a functioning component of a test oracle.

Component-based software engineering is widely expected to revolutionize the way in which software systems are developed and maintained. However, companies who wish to adopt the component paradigm for serious enterprise software development face serious migration obstacles due to the perceived incompatibility of components with traditional, commonly used development approaches. This perception is reinforced by contemporary methods and component technologies, which typically view components as merely "binary-level" modules with little relevance beyond the implementation and deployment phases of development. The authors present a method known as KobrA that embraces the component concept at all phases of the software life-cycle, and allows high-level components (described in the UML) to be implemented using conventional software development approaches, as well as the latest component technologies (e.g. JavaBeans, CORBA, COM). The approach therefore provides a practical vehicle for applying the component paradigm within the context of a model driven architecture. After explaining the noteworthy features of the method, the paper briefly presents an example of its use in the development of an enterprise resource planning system.

Following the successful use of object-oriented metamodeling in the definition of the UML and other notation standards there is increasing interest in extending the approach to cover other concepts of software development, including processes. However, it turns out that the "obvious" approaches for using metamodels to describe processes and artifacts independently do not integrate well together in a natural and straightforward way. In this paper we discuss the problems and inconsistencies than can arise when trying to model a process and the products it creates within the same metamodeling framework, and present a solution that not only avoids many of these problems but also qualifies as a general metamodeling pattern. We then generalize the conceptual architecture to support the sound co-modeling of all independent areas of concern within the context of strict metamodeling.

The value of software inspection for uncovering defects early in the development lifecycle has been well documented.Of the various types of inspection methods published to date, experiments have shown perspective-based inspection to be one of the most effective, because of its enhanced coverage of the defect space.However, inspections in general, and perspective-based inspections in particular, have so far been applied predominantly in the context of conventional structured development methods, and then almost always to textual artifacts, such as requirements documents or code modules.Object oriented-models, particularly of the graphical form, have so far not been adequately addressed by inspection methods.This paper tackles this problem by first discussing the difficulties involved in tailoring the perspective-based inspection approach to object-oriented development methods and, second, by presenting a generalization of the approach which overcomes these limitations.The new version of the approach is illustrated in the context of UML-based object-oriented development.

Meta-modeling is critical to the success of distributed object environments such as CORBA and ActiveXI DCOM. However, there is a surprisingly large variation in the nature of the meta-models (and meta-meta-models) that have been proposed for such environments. This paper investigates this phenomenon by examining the basic tenets of meta-modeling in the context of distributed object environments, and by defining the basic properties required of a suitable meta-modeling framework. The paper is not concerned with the content of the meta-models, per se, but rather with the form that this content should take, and the rules that it should adhere to. The ramifications of these rules on the notations and languages for distributed object environments are then considered.

Dual-lifecycle software processes have the potential to significantly improve the way in which suites of software applications are generated and sustained. However, several outstanding issues need to be more adequately addressed before the full potential of this philosophy can be realized. Detailed strategies for maintaining domain architectures in parallel with suites of fielded applications are at present particularly conspicuous by their absence. In this paper, we present a dual-lifecycle maintenance process that was developed for the ROSE (Reusable Object Software Engineering) project, a major reengineering and repository-building effort in the domain of flight design and dynamics. We present the major features of the process, the rationale behind these features, and changes which we feel would be beneficial based on lessons learned from the application of the process. The process is presented using a variant of the Fusion object-oriented design method known as Profusion.