The maintenance of legacy software systems that were developed using a procedural design approach is becoming increasingly expensive. The procedural approach is often ill suited for complex systems that need to integrate with other codes. Furthermore, these legacy systems are usually written in FORTRAN, for which there is increasingly less personnel available compared to, say, C++. While it would be desirable to convert these legacy systems into object-oriented codes described in C++, such a conversion process is nontrivial. Currently, the structural design must be manually examined, interpreted, and converted into an object-oriented design described in an object-oriented language. Therefore, the conversion process is likely to introduce numerous new inconsistencies and errors, which degrades the software's quality and increases its costs. The preferred solution would be to automate this conversion process. Automation would promote consistency by eliminating the manual variations in interpretation and implementation. It would therefore maximize the likelihood that the converted code does not introduce new errors relative to the original code. The work presented here automates the conversion process from procedural design described in the FORTRAN77 language into object-oriented design described in the C++ language. It demonstrates the extraction of object-oriented elements using FORTRAN common block structures and FORTRAN subroutine and function-calling hierarchies. The result is a consistent, first-cut converted design, which enhances cohesion within classes and reduces coupling between classes. This result is described in the contemporary, broadly used computer language C++, which integrates with adjacent modules that might still remain procedural and described in FORTRAN. / Master of Science

Component-based development is an approach that revolves around the construction of systems form pre-built modular units (components). If legacy code can be reverse engineered to extract components, the extracted components can provide architectural re-usability across multiple systems of the same domain. Current component directed reverse engineering approaches are based on component models that belong to architecture description languages (ADLs). ADL-based components cannot be reused without configurational changes at code level and binding every required and provided service. Moreover, these component models neither support code-independent composition after extraction of components nor the re-deposition of a composed configuration of components for future reuse. This thesis presents a reverse engineering approach that extracts components and addresses the limitations of current approaches, together with a tool called RX-MAN. Unlike ADL-based approaches, the presented approach is based on an encapsulated component model called X-MAN. X-MAN components are encapsulated because computation cannot go outside of a component. X-MAN components cannot interact directly but only exogenously (composition is defined outside of a component). Our approach offers code-independent composition after extracting components and does not need binding of all the services like ADLs. The evaluation of our approach shows that it can facilitate the re-usability of legacy code by providing code-independent composition and re-deposition of composed configurations of components for further reuse and composition.

Legacykod är något som är svårt för utvecklare att förhindra. Medan det finns mycket forskning kring att motarbeta legacykod och förnya legacysystem som använder utdaterade teknologier och designer, så har inte mycket fokus lagts på hur legacykod kan identifieras i sitt tidigaste skede. Hur dessutom definierar man legacykod? I denna studie så görs en litteraturstudie för att ta reda på vad för forskningsbakgrund det finns bakom legacykod i allmänhet. Därefter så utvecklas två prototyper i syfte att upptäcka mönster under utvecklingen som kan vara egenskaper till legacykod. I slutändan så utförs en enkät riktade åt mjukvaruutvecklare för att få insyn och tankar på vad legacykod betyder för dem och för att testa idéerna som togs fram från implementationerna. Den rekommenderade definitionen för legacykod är kod som inte har testats, ingen eller för lite dokumentation och är allmänt svår att förstå, vare sig med dokumentation eller utan. Observationerna från implementation av de två prototyperna bildade 7 riktlinjer som tar upp hur man kan identifiera uppväxten av legacykod. / Legacy code proves to be something difficult for developers to prevent. While much research exists to combat legacy code and renewing legacy systems that use outdated technologies and designs, not much focus has been put on how legacy code can be detected at its earliest stage. And how do you define legacy code? In this study, a literature review is done to find out the scientific background behind legacy code in general. Afterwards, two implementations of the same software are done to observe any events during the software development that can be characteristics of legacy code. In the end phase, a questionnaire-based survey is handed out to developers to get their insight and thoughts on what legacy code means to them and to test the ideas brought up from the implementations. A recommended definition for legacy code is code with no testing and little to no documentation and generally being hard to understand, whether with documentation or not. From the observations implementing the prototypes, 7 guidelines are formed to help identify and discover legacy code evolution.

This thesis elaborates the Model-Driven Software Modernization (MDSM), that has been identified by us, and is defined as a group of approaches toward modernization of legacy code. MDSM approaches are based on models, tools and processes known from the Model-Driven Engineering (MDE) that aims in automation of modernization process. This thesis describes identified MDSM approaches and related standards. Additionally, it suggests that certain kinds of modernization can be implemented in a more efficient way, when a new approach, that has been proposed by the authors, is used. An exemplary modernization, that solves selected industry problem, is implemented to demonstrate that the alternative approach is feasible. In addition, the availability of tools for MDA, which can be adopted in MDSM process, is discussed and guidelines for implementing MDSM are proposed.

Hardware evolves faster than software. While a hardware system might need replacement every one to five years, the average lifespan of a software system is a decade, with some instances living up to several decades. Inevitably, code outlives the platform it was developed for and may become legacy: development of the software stops, but maintenance has to continue to keep up with the evolving ecosystem. No new features are added, but the software is still used to fulfil its original purpose. Even in the cases where it is still functional (which discourages its replacement), legacy code is inefficient, costly to maintain, and a risk to security. This thesis proposes methods to leverage the expertise put in the development of legacy code and to extend its useful lifespan, rather than to throw it away. A novel methodology is proposed, for automatically exploiting platform specific optimisations when retargeting a program to another platform. The key idea is to leverage the optimisation information embedded in vector processing intrinsic functions. The performance of the resulting code is shown to be close to the performance of manually retargeted programs, however with the human labour removed. Building on top of that, the question of discovering optimisation information when there are no hints in the form of intrinsics or annotations is investigated. This thesis postulates that such information can potentially be extracted from profiling the data flow during executions of the program. A context-aware data dependence profiling system is described, detailing previously overlooked aspects in related research. The system is shown to be essential in surpassing the information that can be inferred statically, in particular about loop iterators. Loop iterators are the controlling part of a loop. This thesis describes and evaluates a system for extracting the loop iterators in a program. It is found to significantly outperform previously known techniques and further increases the amount of information about the structure of a program that is available to a compiler. Combining this system with data dependence profiling improves its results even more. Loop iterator recognition enables other code modernising techniques, like source code rejuvenation and commutativity analysis. The former increases the use of idiomatic code and as a result increases the maintainability of the program. The latter can potentially drive parallelisation and thus dramatically improve runtime performance.

A mature code-base of 1 300 000 LOC for a period of 20 months has been examined. This paper investigates if churn is a significant factor in finding refactoring candidates. In addition it looks at the variables Lines of Code (LOC), Technical Debt (TD), Duplicated lines and Complexity to find out if any of these indicators can inform a coder as to what to refactor. The result is that churn is the strongest variable out of the studied variables followed by LOC and TD. / En kodbas på 1 300 000 rader kod har undersökts under 20 månader. Denna uppsats undersöker om kodens användningsfrekvens är en signifikant faktor för att finna refaktoreringskandidater. Uppsatsen tittar även antal kodrader, teknisk skuld, antal duplicerade kodrader och komplexitet för att undersöka om dessa indikatorer kan informera en programmerare om vad som ska refaktoreras. Resultatet är att kodens användningsfrekvens är den starkaste variabeln följt av antal kodrader samt teknisk skuld.

Retirement of old IT - systems to newer ones has become more up-to-date, due to increases in performance in hardware and new programming languages. Nevertheless for companies it is not uncomplicated how this retirement process is best handled, and there are not many studies covering this phenomenon. In this thesis the goal is to find general guidelines regarding retirement of IT - systems. This is done by doing a case study on retirement for the old (MAPPER/BIS) platform to a more modern C# system which is currently used at Handelsbanken, one of Sweden’s largest banks. With the help of a qualitative research method, literature study and with interviews at Handelsbanken and external parts, we aim to understand and analyze what’s important in a retirement process. In order to create recommendations for our guidelines by also using some parts from the EM3: Software Retirement Process Model. The result of the thesis report is in total 16 guidelines that are presented as tables in the study, which companies can use in their retirement process. Ten guidelines are concerned with the retirement of the platform and six guidelines regarding conversion rules. Nonetheless the study has shown that not all systems on the MAPPER platform were possible to retire. / Pensionering av IT-system har idag blivit en mer aktuell fråga än någonsin, till följd av att system blir gamla och inte är anpassade till dagens hårdvara eller moderna programmeringsspråk. Det är inte okomplicerat hur en sådan pensionering ska ske, speciellt då det inte gjorts så många studier kring det ämnet. I denna uppsats är målet att ta fram riktlinjer gällande pensionering, detta gjordes genom att utföra en fallstudie. Fallstudien gjordes på uppdrag av Handelsbanken, en av de största bankerna i Sverige, kring pensionering av (MAPPER/BIS) plattformen till en annan mer moderna plattform i C#. Med hjälp av en kvalitativ forskningsmetod, litteraturstudie samt intervjuer med personal på Handelsbanken och externa parter, ämnar vi att förstå och analysera vad som är viktigt vid en pensioneringsprocess. För att kunna skapa rekommendationer till de riktlinjer kring pensionering som detta arbete presenterar. Vissa utvalda delar av EM3: Software Retirement Process Model kommer också att ligga till grund för riktlinjerna. Uppsatsrapporten har resulterat i totalt 16 riktlinjerna som presenteras i tabeller som företag kan använda i sina pensioneringsprocesser. Tio stycken riktlinjer grundar sig i pensioneringen av en plattform och ytligare sex stycken gäller konvertering. Studien visade dock att alla system på MAPPER plattformen inte var möjliga att pensionera.

This project explores the narrative arcs of strong female characters in Young Adult (YA) fantasy literature. Taking up Rosemary Jackson’s assertion that fantasy literature can ‘subvert patriarchal society,’ this thesis examines the fantasy ‘legacy code’ of strong and subversive female characters who settle into a stereotypical performance of gender after finding fulfillment in the heteronormative roles of lover, wife, and mother. This pattern is exemplified by Lady Éowyn of J.R.R. Tolkien’s The Two Towers (1954) and The Return of the King (1955), and reproduced by Hermione Granger of J.K. Rowling’s Harry Potter series – consisting of Harry Potter and the Philosopher’s Stone (1997), Harry Potter and the Chamber of Secrets (1998), Harry Potter and the Prisoner of Azkaban (1999), Harry Potter and the Goblet of Fire (2000), Harry Potter and the Order of the Phoenix (2003), Harry Potter and the Half-Blood Prince (2005), and Harry Potter and the Deathly Hallows (2007). In contrast Keladry of Mindelan in Tamora Pierce’s Protector of the Small series – consisting of First Test (1999), Page (2000), Squire (2001), and Lady Knight (2002) – demonstrates the impact ‘refactoring’ fantasy ‘legacy code’ has on the narrative conclusions of female characters. Using Judith Butler’s theory on the performative nature of gender and building on Farah Mendlesohn’s computer programming analogy of ‘legacy code,’ this thesis illustrates the ways in which fantasy literature often fails to be the literature of subversion Jackson envisions, and demonstrates how refactoring aspects of a female character’s narrative exemplifies subversive narrative conclusions for young adult readers of fantasy literature. / Thesis / Master of Arts (MA) / This thesis examines the ways in which a heteronormative ‘legacy code’ – exemplified by Lady Éowyn in J.R.R. Tolkien’s Lord of the Rings – has been perpetuated in literature marketed towards young adult readers by Hermione Granger in J.K. Rowling’s Harry Potter series and ‘refactored’ by Keladry of Mindelan in Tamora Pierce’s Protector of the Small series. Starting with Rosemary Jackson’s analysis of fantasy literature as a genre with subversive potential and with Judith Butler’s assertion that gender is performative, this thesis analyses the narrative arcs of Éowyn, Hermione, and Kel and demonstrates how the continual representation of strong female characters finding fulfillment in the roles of lover, wife, and mother is limiting, and highlights the subversive potential in ‘refactoring’ heteronormative ‘legacy code.’