Search

SWForum.eu Way Forward Workshop: Future Challenges in Software Engineering, held on 27 June 2023 at the Politecnico di Milano (POLIMI), in the Dipartamento di Elettronica, Informazione e Bioingegneria (DEIB), featured a dynamic agenda that encompassed a comprehensive range of topics and discussions. With a focus on emerging trends, technological advancements, and industry insights, the event provided a platform for attendees to gain a deeper understanding of the challenges and opportunities awaiting the software engineering community. Unlock the power of knowledge sharing! Embrace the opportunity to showcase your expertise and connect with peers on Online SW-Forum, an accessible and free platform. With our thriving community of nearly 3,000 SWForum members, your contributions will have a far-reaching impact. Let's amplify your voice by spreading this valuable information through your networks and channels. Together, we can create a ripple effect of knowledge and collaboration. Follow us on our pages: 🎓LinkedIn company/SWForumEU 💬Twitter: @SWforumEU ₪ Website: www.SWForum.eu

Cloud Computing has assumed a relevant role in the ICT, profoundly influencing the life-cycle of modern applications in the manner they are designed, developed, and deployed and operated. In this article, we tackle the problem of supporting the design-time analysis of Cloud applications to identify a cost-optimized strategy for allocating components onto Cloud Virtual Machine infrastructural services, taking performance requirements into account. We present an approach and a tool, SPACE4Cloud, that supports users in modeling the architecture of an application, in defining performance requirements as well as deployment constraints, and then in mapping each architecture component into a corresponding VM service, minimizing total costs. An optimization algorithm supports the mapping and determines the Cloud configuration that minimizes the execution costs of the application over a daily time horizon. The benefits of this approach are demonstrated in the context of an industrial case study. Furthermore, we show that SPACE4Cloud leads to a cost reduction up to 60 percent, when compared to a first-principle technique based on utilization thresholds, like the ones typically used in practice, and that our solution is able to solve large problem instances within a time frame compatible with a fast-paced design process (less than half an hour in the worst case). Finally, we show that SPACE4Cloud is suitable to model even microservice-based applications and to compute the corresponding optimized deployment configuration which is compared with a state-of-the art meta-heuristic alternative method, achieving savings between 21 and 85 percent.

This deliverable is the second of a set of deliverables presenting the results from the work of task T3.3 - Definition and creation of aGovernance structure and business model. It provides an overview of the current status of the concrete steps conducted by theSWForum project to develop a long-lasting organization focusing on software engineering and acting as a collector and amplifier ofthe ideas and initiatives emerging from the European software engineering community. Moreover, it presents the plan for the futuresteps aiming at consolidating the community and finalizing its structure and governance mechanisms (including decisionmechanisms, conflict resolution, and membership types). This second release includes also the exploitation plans of SWForum.eu.

Big Data or Data-Intensive applications (DIAs) seek to mine, manipulate, extract or otherwise exploit the potential intelligence hidden behind Big Data. However, several practitioner surveys remark that DIAs potential is still untapped because of very difficult and costly design, quality assessment and continuous refinement. To address the above shortcoming, we propose the use of a UML domain-specific modeling language or profile specifically tailored to support the design, assessment and continuous deployment of DIAs. This article illustrates our DIA-specific profile and outlines its usage in the context of DIA performance engineering and deployment. For DIA performance engineering, we rely on the Apache Hadoop technology, while for DIA deployment, we leverage the TOSCA language. We conclude that the proposed profile offers a powerful language for data-intensive software and systems modeling, quality evaluation and automated deployment of DIAs on private or public clouds.

Distributed streaming applications, i.e. applications that process massive and potentially infinite streams of data, are becoming increasingly popular in order to tame at the same time the velocity and the volume of Big Data. Designing and developing distributed streaming applications is currently difficult because it involves the employment of 1) complex programming paradigms to deal with the unboundedness of data streams together with 2) distributed streaming engines, each coming with its own APIs. To address the above shortcomings, in this tool demo paper we present StreamGen, a model-driven tool aiming at simplifying the development of distributed streaming applications. StreamGen provides (i) a UML profile to add streaming-specific concepts to standard UML Class Diagrams and (ii) a model-to-text transformation to automatically generate the application code starting from UML models.

As part of the DevOps tactics, Infrastructure-as-Code (IaC) provides the ability to create, configure, and manage complex infrastructures by means of executable code. Writing IaC, however, is not an easy task, since it requires blending different infrastructure programming languages and abstractions, each specialized on a particular aspect of infrastructure creation, configuration, and management. Moreover, the more the architectures become large and complex (e.g. Data-Intensive or Microservice-based architectures), the more dire the need of IaC becomes. The goal of this paper is to exploit Model-Driven Engineering (MDE) to create language-agnostic models that are then automatically transformed into IaC. We focus on the domain of Data-Intensive Applications as these typically exploit complex infrastructures which demand sophisticated and fine-grained configuration and re-configuration — we show that, through our approach, called DICER, it is possible to create complex IaC with significant amounts of time savings, both in IaC design as well as deployment and re-deployment times.

DevOps entails a series of software engineering tactics aimed at shortening the actionable operation of software design changes. One of these tactics is to harness infrastructure-as-code, that is, writing a blueprint that contains deployment specifications ready for orchestration in the cloud. This abstract briefly discusses all necessary elements and abstractions in writing and maintaining that blueprint, revolving around a key standard for its expression, namely, the OASIS "Topology and Orchestration Specification for Cloud Applications" (TOSCA) industrial standard adopted by as many as 60+ big industrial players worldwide.

This books is open access under a CC BY 4.0 license. This book summarizes work being undertaken within the collaborative MODAClouds research project, which aims to facilitate interoperability between heterogeneous Cloud platforms and remove the constraints of deployment, portability, and reversibility for end users of Cloud services. Experts involved in the project provide a clear overview of the MODAClouds approach and explain how it operates in a variety of applications. While the wide spectrum of available Clouds constitutes a vibrant technical environment, many early-stage issues pose specific challenges from a software engineering perspective. MODAClouds will provide methods, a decision support system, and an open source IDE and run-time environment for the high-level design, early prototyping, semiautomatic code generation, and automatic deployment of applications on multiple Clouds. It will free developers from the need to commit to a fixed Cloud technology stack during software design and offer benefits in terms of cost savings, portability of applications and data between Clouds, reversibility (moving applications and data from Cloud to non-Cloud environments), risk management, quality assurance, and flexibility in the development process.

Distributed Software Development course is a joint project-based course involving three universities, from Croatia, Sweden and Italy, running each year since 2003. Distributed student teams work on all phases of a complex software engineering project, solving several challenges of working in a global environment, thus obtaining a valuable experience for their future careers. The course is very well received by both the students and course partners from the industry.

Data intensive applications that leverage Big Data technologies are rapidly gaining market trend. However, their design and quality assurance are far from satisfying software engineers needs. In fact, a CapGemini research shows that only 13% of organizations have achieved full-scale production for their Big Data implementations. We aim at addressing an early design and a quality evaluation of data intensive applications, being our goal to help software engineers on assessing quality metrics, such as the response time of the application. We address this goal by means of a quality analysis tool-chain. At the core of the tool, we are developing a Profile that converts the Unified Modeling Language into a domain specific modeling language for quality evaluation of data intensive applications.

ICT and, in particular, software is more and more pervasive. Current investments in R&D in this area are limited in Europe, compared to other partner countries. Moreover, software should not be considered a minor element of a complex systems. In domains like cloud, big data, IoT, cyber-physical systems it is the core element. We need to consolidate the software engineering discipline, which, despite the impressive achievements in the area of software technology, is probably one of the youngest scientific and technological disciplines with about 60 years of history. This will increase also our ability to deal with a large number of challenges in other disciplines, from the achievement of a complete digitalization of public administrations and businesses to the actual development of smart cities, to the development of reliable software for science, to the discovery of new fields that we cannot imagine today. In this context, this paper summarizes the current challenges that the Software Engineering for Services and Applications (SE4SA) cluster is tackling alongside with a number of medium-term issues to be addressed in the next years by research in this field.

DevOps is an emerging software engineering strategy entailing the joined efforts of development and operations people, their concerns and best practices with the purpose of realising a coherent working group for increased software development and operations speed. To allow software architecture practitioners to enrich and properly elaborate their architecture specifications in a manner which is consistent with DevOps, we surveyed a number of DevOps stakeholders. We studied concerns and challenges to be tackled with respect to preparing a software architecture which is DevOps-ready, i.e., described in all details needed to enact DevOps scenarios. Subsequently, we introduce SQUID, that stands for Specification Quality In DevOps. SQUID is a software architecture framework that supports the model-based documentation of software architectures and their quality properties in DevOps scenarios with the goal of providing DevOps-ready software architecture descriptions. We illustrate our framework in a case-study in the Big Data domain.

Social and technical debt both represent the state of software development organizations as a result of accumulated decisions. In the case of social debt, decisions (and connected debt) weigh on people and their socio-technical interactions/characteristics. Digging deeper into social debt with an industrial case-study, we found that software architecture, the prince of development artefacts, plays a major role in causing social debt. This paper discusses a key circumstance wherefore social debt is connected to software architectures and what can be done and measured in response, as observed in our case-study. Also, we introduce DAHLIA, that is "Debt-Aimed Architecture-Level Incommunicability Analysis" - a framework to elicit some of the causes behind social debt for further analysis.

Migration of legacy systems to service-based systems constitutes a key challenge of service-oriented system engineering, namely rehabilitation of pre-existing enterprise assets while conforming to service engineering principles. Over a decade there has been an increasing interest in the approaches addressing SOA migration. These approaches mainly differ in 'what is migrated' and 'how the migration is performed'. Such differences aggravate achieving a general understanding of 'what SOA migration entails'. To solve this problem, we conducted a systematic review that extracts main migration categories, called SOA migration families, from the approaches proposed in the research community. Based on the results of the systematic review, we describe eight distinct families along with their characteristics and goals. These families represent a first frame of reference for SOA migration which brings order and enhances understanding on how migration can be carried out. © 2010 Springer-Verlag.

The importance of planning and management skills in software development is very difficult to convey in software engineering courses. We present the synopsis of an assignment whose purpose is to demonstrate the significance of such skills, including effective communication, team coordination and collaboration, and overall project planning. The assignment is organized in the context of a distributed software engineering course carried out in collaboration with 12 universities in South America, Europe and Africa. The assignment is a globally distributed contest issued before most development activities related to the course's software project are performed, aiming at favoring the collaboration between students prior to project development. The contest does not involve any programming, and is not related to the project development activities. Instead, it consists of making teams in different countries compete in collaboratively solving a set of very simple tasks. The complexity of the activity is in team collaboration and coordination, and their lack is evident when the tasks are not correctly solved, or not solved in time. Despite the simplicity of the as-signment, students have found it useful in helping them understand the significance of management and planning challenges in distributed software development. Moreover, the assignment helped in team building, by creating a better team atmosphere and contributing in identifying team members better suited for management.

This paper presents a report of the International Workshop on Service Oriented Software Engineering colocated with ICSE2006. In particular, we shortly present the papers that have been accepted for publication in the workshop proceedings, the keynote speech, and the discussion topics that have emerged during the workshop.

Current practice in software engineering suggests a radical change in perspective: where once stood fixed teams of people following a development plan, now stand just-in-time Dynamic Networked Organizations (DyNOs), adopting a common flexible strategy for development, rather than a plan. This shift in perspective has gone relatively unnoticed by current software engineering research. This paper offers a glimpse at what processes and instruments lie beyond “current” software engineering research, where studying emergent DyNOs, their creation and steering becomes critical. To understand the underpinnings of this evolution, we explored a simple yet vivid scenario from real-life industrial practice. Using scenario analysis we elicited a number of social and organizational requirements in working with DyNOs. Also, comparing our evidence with literature, we made some key observations. First, managing DyNOs makes organizational requirements a first-class entity for development success. Second, research in software engineering should be invested in understanding and governing the DyNOs behind the software lifecycle.

Most modern business activities are carried out by a combination of computerized tools and human agents. Typical examples are engineering design activities, office procedures, and banking systems. All these human-centered systems are characterized by the interaction among people, and between people and computerized tools. This interaction defines a process, whose effectiveness is essential to ensure the quality of the delivered products and/or services. To support these systems, process-centered environments and workflow management systems have been recently developed. They can be collectively identified with the term process technology . This technology is based on the explicit definition of the process to be followed (the process model ). The model specifies the kind of support that has to be provided to human agents. An essential property that process technology mut exhibit is the ability of tolerating, controlling, and supporting deviations and inconsistencies of the real-world behaviors with respect to the proocess model. This is necessary to provide consistent and effective support to the human-centered system, still maintaining a high degree of flexibility and adaptability to the evolving needs, preferences, an expertise of the the human agents. This article presents a formal framework to characterize the interaction between a human-centered system and its automated support. It does not aim at introducing a new language or system to describe processes. Rather, it aims at identifying the basic properties and features that make it possible to formally define the concepts of inconsistency and deviation. This formal framework can then be used to compare existing solutions and guide future research work.

Software development is a cooperative activity that relies heavily on the quality and effectiveness of the communication channels established within the development team and with the end-user. Process-centered software engineering environments (PSEEs) support the definition and the execution of various phases of the software process. This is achieved by explicitly defining cooperation procedures, and by supporting synchronization and data sharing among its users. PSEE and CSCW technologies have been developed rather independently from each other, leading to a large amount of research results, tools and environments, and practical experiences. We have reached a stage in technology development where it is necessary to assess and evaluate the effectiveness of the research efforts carried out so far. Moreover, it is important to understand how to integrate and exploit the results of these different efforts. The goal of the paper is to understand which kind of basic functionalities PSEEs can and should offer, and how these environments can be integrated with other tools to effectively support cooperation in software development. In particular, the paper introduces a process model we have built to support a cooperative activity related to anomaly management in an industrial software factory. The core of the paper presents and discusses the experiences and results that we have derived from this modeling activity, and how they related to the general problem of supporting cooperation in software development. The project was carried out using the SPADE (Software Process Analysis, Design and Enactment) PSEE and the ImagineDesk CSCW toolkit.

Distributed software development poses new software engineering challenges. To prepare student for these new challenges, we have been teaching software engineering using globally distributed projects. The projects were developed in collaboration with eleven universities in ten different countries in Europe, Asia, and South America. This paper reports the experience teaching the course, describing the settings, problems faced organizing the projects and the lessons learned.

Software projects have crossed seas and continents looking for talented developers, moving from local developments to geographically distributed projects. This paper presents a case study analyzing the effect of distribution and time zones on communication in distributed projects. The study was performed in a university course during two semesters, where students developed projects jointly with teams located in ten different countries in South America, Europe, and Asia. The study compares the results of the projects distributed in two locations with projects distributed in three locations. It also analyzes projects in different time zone ranges. The initial results show that the amount of communication in projects distributed in two locations is bigger than the communication in projects distributed in three locations. We also found that projects in closer time zones have more communication than projects in farther time zones. Furthermore, we analyze the reply time for e-mails of projects distributed in different time zones, and discuss the challenges faced by the students during these projects.

The current research trends in Software Engineering are focusing on the development of new techniques to deal intelligently and efficiently with the design of systems that are able to evolve overtime and adapt to rapid changes of their requirements. In particular, the field of Autonomic Computing has been created to study these types of systems with the ultimate aim to create systems that are able to self-configure, self-optimize, self-heal and self-protect without any external intervention. What we study in this paper is a set of the most relevant bio-inspired principles that may be applied to these systems. We discuss how to apply them to develop or adapt self-organization algorithms to real evolvable systems and we present two examples of applications that we have developed.

The wide diffusion of reliable Internet is pushing two key novelties in the conception of modern software applications: the Software as a Service paradigm and the idea of the Internet of Things. Traditionally, services and things have been considered as separate entities, even addressing different needs and application domains. In contrast, we feel that services and things should be integrated and demand for proper design and programming paradigms that ease the task of system builders and enable reuse of components through various systems. Furthermore, we also see the need to take into account the many cross-cutting issues that are typical of any complex application (e.g., security, user interface, transactionality). We suggest multidimensional service assembly as the right abstraction for taking into account all these different aspects. In this paper we sketch our ideas, discuss the implications of multi-dimensional service assembly, and draft a research agenda that goes towards the development of a well established theory in this area.

The objective of this workshop is to discuss about the importance of software engineering methods and techniques for service-oriented systems and, vice versa, about the impact that such kinds of open and natually adaptable systems can have on traditional software engineering. We think that discussing about these aspects within the ICSE community could be very beneficial for the progress of the field.

Distributed software development raises new software engineering challenges resulting from the difficulty of making several teams cooperate across different countries, time zones and cultures. These obstacles can lead to critical delays or even failures. One of the most effective techniques for overcoming them is to improve the quality of software specifications. Our experience with a distributed software project in an educational environment suggests that Design by Contract techniques provide a promising solution.

Research about service oriented architectures produced, in the last years, some frameworks that enable the development of self-adaptive service compositions supporting dynamic binding. A developer can specify, at design time, an abstract service. At run time a concrete implementation of the abstract service is dynamically selected. In this scenario service selection is usually performed assuming that all the implementations of an abstract service have the same interface or protocol. This assumption is not necessarily true in an open world setting, where services built by different organizations are made available. In this paper we address the problem of invoking services having an interface or protocol different from those originally expected by the service requester. We have identified a number of possible mismatches between services and some basic mapping functions that can be used to solve simple mismatches. Such mapping functions can be combined in a script to solve complex mismatches. Scripts can be executed by a mediator that receives an operation request, parses it, and eventually performs the needed adaptations. The definition of the scripts can be partially automated.

Software engineering practitioners and researchers continue to face huge challenges in the development, maintenance, and use of software systems. This has been even more prominent with the new paradigm of service oriented computing in which service integrators, developers, and providers need to create methods, tools, and techniques to support costeffective development and use of dependable services and service oriented applications. From a technological point of view, recent years have seen the emergence of important standards enabling the Service Oriented vision; however, the engineering of complex and dependable service oriented software still lacks powerful, effective methods and tools. The International Workshop on Service Oriented Software Engineering (IW-SOSE’06) is intended to provide a

The rapid diffusion of service-oriented systems is becoming a reality in today's software engineering. In particular, an aspect that is gathering the interest of researchers and practitioners is the possibility to create compositions of dynamically bound services. This paper describes WS Binder, a framework for enabling dynamic binding of service compositions according to some functional and non-functional preferences and/or constraints. The framework is also able to support run-time recovery actions, by performing service re-binding. The paper describes the framework's architecture and highlights its features by describing an example of its usage for the binding and re-binding of a service composition related to the tourism domain.

Architecture definition languages (ADLs) enable the formalization of the architecture of software systems and the execution of preliminary analyses on them. These analyses aim at supporting the identification and solution of design problems in the early stages of software development. We have used ADLs to describe middleware-induced architectural styles. These styles describe the assumptions and constraints that middleware infrastructures impose on the architecture of systems. Our work originates from the belief that the explicit representation of these styles at the architectural level can guide designers in the definition of an architecture compliant with a pre-selected middleware infrastructure, or, conversely can support designers in the identification of the most suitable middleware infrastructure for a specific architecture. In this paper we provide an evaluation of ADLs as to their suitability for defining middleware-induced architectural styles. We identify new requirements for ADLs, and we highlight the importance of existing capabilities. Although our experimentation starts from an attempt to solve a specific problem, the results we have obtained provide general lessons about ADLs, learned from defining the architecture of existing, complex, distributed, running systems.

This chapter has illustrated the complexity of cooperation control in software processes and the variety of approaches which can be followed to solve the related problems.

To address this issue, researchers in the field of software architecture are defining a number of languages and tools that support the definition and validation of the architecture of systems. Also, a number of architectural styles are being formalized. Each of them defines “a set of design rules that identify the kinds of components and connectors that may be used to compose a system or a subsystem, together with local or global constraints on the way the composition is done” [5]. The formalization of styles helps the understanding and categorization of existing architectures and supports developers in the definition of the structure of new systems.

A fundamental problem in software processes is how the intrinsic rigidity of a predefined (formal) model can be reconciled with the need for flexibility, change, and evolution. We therefore distinguish between software processes, as specified in a process description, and their actual performance by humans. Further, we claim that the two inevitably diverge, and thus it is necessary to provide means to reconcile them. We present a preliminary exploration into the problem. In particular, we illustrate how a temporal logic-based approach can be used to capture and tolerate some deviations from the process description during execution. We present a simple process language (LATIN), and its prototype environment (SENTINEL), in which these ideas are currently experimented.

This paper discusses the characteristics that should be offered by PSEEs (process-centered software engineering environments) to support the evolution of the software process. A PSEE is a software engineering environment based on the explicit representation of the software process (the process model). Processes and process models are dynamic entities that need to evolve. Existing PSEEs offer limited capabilities to support process evolution. To address this issue, it is necessary to extend PSEEs with features that enable the process manager to effectively and consistently change the process. The design of these functionalities must be guided by a clear characterization of the evolution problem. In particular, it is necessary to understand what kinds of services a PSEE should offer as built-in mechanisms, and what kinds of functionalities have to be implemented by the process modeler as process-specific policies. >