Considering the need to close the gap that exists in the IT sector, universities play a fundamental role in teaching women and men how to program. The Universidad de los Andes and the CSBridge association of Stanford University joined forces to teach High School students how to code in the Colombian context during the summer vacations of 2022. This document is a retrospective report of the experience and a collection of identified areas of improvement. These areas of improvement are meant for 1) students to have a better perspective towards programming and 2) to attract a greater number of women to the IT sector. Although this experience was based in the Colombian context, these proposals can be adapted to different contexts.

In DevOps, practices for continuous delivery aim to minimize the risks associated with releasing software and new features. Adding automation to the process, these practices help to reduce the effort required to deploy the software without affecting the behaviour of the system. Regretfully, when developers or infrastructure administrators modify any element in a system, other elements may result in affected, thus producing errors and service interruptions. Here we present the tool Cloud architecture Mapper (ClarchMap) that determines what elements comprise a given cloud-based system and what dependencies exist among these elements. Users can take advantage of this information to analyse the impact of changes. Our approach uses different kinds of APIs to reconstruct the system architecture and visualize, and analyse the diverse software, data, and infrastructure elements therein. We have applied our approach to reconstruct and analyze the infrastructure used in a real Software as a Service application in Azure. According to this evaluation, the contributed graph-based visualizations help to detect elements and problems hard to find by hand. A video demonstrating our tool is available from https://www.youtube.com/watch?v=uXBZ4P1ZGRE

Abstract New code in projects can introduce violations that deviate the code implementation from the intended architecture. This process is known as architecture erosion. In this article, we propose an approach for recovering the implemented architecture, and detecting violations when comparing it with the intended architecture. Given a code repository, the continuous integration pipeline calls the solution to detect the incidences of architecture violations as well as some quality and social metrics. This data is presented in metric‐centered views that help development teams to manage architecture erosion. Our approach is based on model‐driven engineering techniques since models serve to represent the code, and a model‐based pattern language helps us to automate the search for violation occurrences and execute corresponding actions (e.g., creation/assignment of issues). We confirm the approach benefits in a real project implemented by a software developing company, in a sample project available on the internet, and in a software development course, including 20 projects, where every single project decreases its architecture violations density through time.

Abstract The migration of software is an economically important niche since the daily operations of many business still rely on systems based on legacy technologies. Migration to more recent technologies comes with major technical and management challenges mainly related to knowledge‐loss issues on the specific technology but also on the architecture and design of the legacy. This article presents a method that addresses the reverse/forward engineering tasks as well as some management challenges such as the planning of the migration based on a better understanding of the system. The process relies on the use of models and transformations to create high‐level abstraction views of the legacy. A big challenge with the migration of certain legacy applications is that much of the business logic is inside triggers which are written in the PL/SQL language and scattered across the application layers. Therefore, developers need to know what they need to migrate and where it is. The main contribution of our work is that the abstractions allow developers to understand and plan the migration without the need of having a vast knowledge on the initial technology. Furthermore, our views help developers to decide about the structure and business logic they want to have in the target system. In this article, we describe the application of the method to the Oracle Forms case study. Nevertheless, the approach can be generalized to other technologies through new bridges that transform from said technologies to the abstract views. The article ends by reporting lessons learned from our experience.

Agile Development values working software over documentation. Therefore, in maintenance stages of existing software, the source code is the sole software artifact that developers have for analyzing the viability and impact of a new user story. Since functionality is often spread in hundreds of lines of code, it is hard for the developer to understand the system, which may lead to under-/overestimation of the new feature cost and rework/delays in the subsequent phases of development. In a previous work, we proposed a Model-Driven Reverse Engineering approach for obtaining software visualizations from source code. Two case studies of comprehension of applications written in statically typed languages have shown the applicability of this approach. A recent experience with an industrial partner, where the systems are developed on dynamically typed languages, has motivated us to adapt the previous proposal to take as input not only the source code but also the application data schema to complete the information that is missing in the code, and then automatically generate more meaningful diagrams that help developers in maintenance tasks. In this article, we present the adaptation of the general approach to support data schema as an additional input and its instrumentation in an industrial case study where the technology is Ruby on Rails. The paper ends by explaining the precision and performance of the instrumentation when used in a Colombian company as well as lessons learned.

Organizations introduce changes to adapt themselves to the extremely changing context. These changes often impact business and information technology (IT) domains. In most of the cases, the scope of the organizational elements in these domains requiring adaptation is not well defined, leaving out elements, what can lead to misalignment. Thus, it is important to know the impact scope in order to perform a full adaptation. When reviewing the literature in the business–IT alignment field, we found that there are no works dealing with this aspect. To fulfill this lack, we carry out a systematic review of change management works and find out a set of clues. We apply them to the business–IT alignment field and as a result propose a change management metamodel, a set of rules and an algorithm to forecast impact scope and adaptations. To operationalize our contributions, we propose a software and demonstrate its applicability through a case study.

Nowadays, software development teams face the challenge of maintenance and evolution of large applications. This is known as modernization and comprises a process of understanding the existing application, and a process of transforming from the as-is state to the to-be state. In this article, we present an approach to modernize legacy applications into microservices. We propose a model-centered process to analyze and visualize the current structure and dependencies between the business layer and the data layer. Furthermore, we propose a modularization into clusters and microservices using four different diagrams. To validate our approach we have analyzed a JEE application with over 74566 LoC. The results show that the understanding is greatly improved through the diagrams proposed, and the modularization proposed constitutes the first step towards the automated modernization of the application.