Legacy Code

pela orientação que me deu, sempre com muita atenção e entusiasmo. Pelo direcionamento que deu à pesquisa, tão essencial para aproveitar ao máximo as minhas potencialidades. Pela oportunidade de voltar à pesquisa e poder associá-la à prática profisssional. Aos professores do ICMC pela acolhida calorosa depois de dez anos de afastamento da Universidade. Aos Profs. Drs. Norm Kerth e Ralph Johnson pela recepção generosa que me deram na área de pesquisa em padrões de software. À Prof. Dra. Rosângela Dellosso Penteado pela total disponibilidade na execução de trabalhos conjuntos e por sua amizade e atenção. Ao Prof. Dr. Antonio Francisco do Prado pela oportunidade de ter contato com a máquina Draco-Puc. Às alunas de graduação Fabiana Rocha, do ICMC e Tiemi Sakata, da UFSCAR, pelos trabalhos de iniciação científica que contribuiram para as publicações feitas durante a execução deste trabalho. Aos mestrandos, doutorandos, pesquisadores e bolsistas do Laboratório de Engenharia de Software do ICMC pela amizade, atenção e auxílio na utilização de máquinas e programas. Aos colegas da Universidade de Franca pelo apoio e incentivo durante todo o programa de mestrado. Aos colegas do Senac -São Carlos pelo incentivo que me deram para que eu pudesse contribuir efetivamente na atividade de treinamento profissional em que estão empenhados e que são tão importantes para o desenvolvimento do país. Às secretárias da pós-graduação pela atenção, paciência e disponibilidade com que sempre me atenderam. Às secretárias, bibliotecárias e funcionários do ICMC que se mostraram sempre prestativos no meu atendimento. À Fapesp pela bolsa de iniciação científica concedida durante meu curso de graduação que me deu oportunidade de travar os primeiros contatos com a pesquisa e que abriram caminho para as atividades aqui relatadas. Às empresas que me deram a oportunidade de exercer as minhas atividades profissionais na área de consultoria e desenvolvimento de sistemas. Aos meus pais Miguel e Maria Teresa pela educação que me deram e pelo suporte aos meus filhos durante minha ausência. Aos meus irmãos Ailton e Anderson pela disposição e prontidão com que sempre me atenderam nas situações imprevistas. Ao Cirilo pelo companheirismo durante os momentos difíceis, pela dedicação em me substituir junto a nossos filhos durante muitas vezes neste período, pelo incentivo constante e pelas sugestões na correção da ortografia desta dissertação. Ao Thales e ao Vitor pela compreensão da importância deste trabalho para mim. A execução da engenharia reversa orientada a objetos de um sistema legado desenvolvido com orientação procedimental é usada como base para sua reengenharia, seguindo duas abordagens diferentes. Na primeira, o sistema passa por reengenharia com mudança de orientação, por meio de segmentação e, posteriormente, é transformado para uma linguagem orientada a objetos de forma semi-automática. Na segunda, é feito o reconhecimento de padrões recorrentes de software no modelo de objetos produzido pela engenharia reversa, para depois efetuar a reengenharia utilizando esses padrões. Os resultados obtidos por intermédio dessas duas abordagens podem ser comparados quanto à manutenibilidade, legibilidade e reuso. A versão original do sistema legado escolhido para a realização da experiência está implementado na linguagem Clipper e possui cerca de vinte mil linhas de código. Trata-se de uma oficina auto-elétrica e mecânica de veículos. Para a engenharia reversa foi escolhido o método Fusion/RE, sendo feita uma proposta para sua evolução, adicionando um maior detalhamento da etapa de abstração do modelo de análise do sistema. Para mudança de orientação do paradigma de desenvolviemnto, de procedimental para orientado a objetos, são propostas duas etapas adicionais a serem executadas após a aplicação do Fusion/RE: o projeto avante do sistema e a segmentação do programa legado. Indicações sobre como fazer a segmentação são fornecidas. A transformação do código segmentado em Clipper para Java é feita com auxílio da máquina Draco-Puc. Uma estratégia é proposta para o reconhecimento de padrões a partir do modelo de objetos do sistema obtido pela engenharia reversa. Por meio dela, instâncias dos padrões Type-Object, Association-Object, State Across a Collection e Behaviour Across a Collection podem ser reconhecidas. Experiências de implementação de alguns desses padrões, em Delphi, são feitas.

Gadamer, das Tragische und das Klassische 1919, nach der Zäsur des großen Krieges, diagnostizierte Paul Valéry eine Krise des Geistes: "L'oscillation du navire a été si forte que les lampes les mieux suspendues se sont à la fin renversées." 1 1935/36 behauptete Walter Benjamin in seiner gegenwartsdiagnostischen Arbeit zum Begriff des Kunstwerks, dass "Schöpfertum und Genialität, Ewigkeitswert und Geheimnis" unbrauchbar gewordene Begriffe der Kunsttheorie seien. 2 Benjamin lässt keinen Zweifel daran, dass der Kunstbegriff selbst durch die politischen, sozialen, technischen und medialen Entwicklungen bedingt ist und keinen ahistorischen Wesenskern besitzt, von einer Kontinuität der Tradition vorbildlicher Werke ganz zu schweigen. Nach 1945 betonte Hannah Arendt, dass der "Zusammenbruch der Tradition" ein "Denken ohne Geländer" erfordere. 3 Arendt ist davon überzeugt, dass "[e]rst die totalitäre Herrschaft […] die in der Überlieferung so lange gesicherte Kontinuität abendländischer Geschichte wirklich durchbrochen [hat]. Dieser Traditionsbruch ist heute eine vollendete Tatsache […]". 4 1

Software maintenance and innovation are constant challenges across industries, especially as programming languages evolve with technology. Similarly, poor lexicon quality degrades program comprehension, increasing the effort required by developers to improve existing software products. To address these challenges, we propose a novel automated framework that extracts software requirements directly from source code using a baseline AI language model applied to a Java code base. Leveraging natural language processing techniques, the framework validates programs and generates easily readable requirements by analyzing file contents. The framework enhances agility and flexibility by providing comprehensive documentation for existing software systems. It caters to both experienced and less-experienced developers, offering an intuitive graphical user interface and enabling efficient identification and resolution of errors. The resulting output facilitates natural interaction through language processing. By automating the extraction process, the framework allows developers to better understand software systems, make informed decisions, and adapt to evolving needs.

Software maintenance and innovation are constant challenges across industries, especially as programming languages evolve with technology. Similarly, poor lexicon quality degrades program comprehension, increasing the effort required by developers to improve existing software products. To address these challenges, we propose a novel automated framework that extracts software requirements directly from source code using a baseline AI language model applied to a Java code base. Leveraging natural language processing techniques, the framework validates programs and generates easily readable requirements by analyzing file contents. The framework enhances agility and flexibility by providing comprehensive documentation for existing software systems. It caters to both experienced and less-experienced developers, offering an intuitive graphical user interface and enabling efficient identification and resolution of errors. The resulting output facilitates natural interaction through language processing. By automating the extraction process, the framework allows developers to better understand software systems, make informed decisions, and adapt to evolving needs.

With the diffusion of Java in advanced multimedia mobile devices, there is a growing need for speeding up the execution of Java Bytecode beyond the limits of traditional interpreters and just-in-time compilers. In this area, Java coprocessors are viewed as a promising technology, which marries the flexibility of a general purpose microprocessor to run legacy code and lightweight Java methods, with the high performance of a specialized execution engine on speed-critical bytecode. This work proposes and analyzes a microprocessor with FPGA coprocessor architecture with efficient shared-memory communication support. Furthermore, we describe a complete run-time environment that supports dynamic migration of Java methods to the coprocessor, and we quantitatively analyze speedups achievable under a number of system configurations using an accurate complete-system simulator.

Trend is growing towards using complex multimedia functions on smaller devices. In this study, we explore the effect of migrating legacy signal processing software applications algorithms from large form factor devices to the smaller one such as handheld mobile devices known as Energy Conscious Mobile Computing Systems (EConMCS). We concentrate on Source Code Volatility (SCV), including inherent algorithm complexity and the developer implementation. We identify code Transformation Steering Factors (TSF), such as loop unrolling factor, decision tree grafting factor and their relation to SCV. The impact of TSF is discussed for different multimedia applications in native Digital Signal Processor (DSP) compiler optimization while switching between different transformation schemes. Our results show that SCV can be minimized by using an architecture-centric algorithm that both enables the effective use of underlying hardware architectures and the memory access required to optimize energy consumption. The coded spatial access is implicitly dependent on layout, content and location of options and legibility that relates to a developer's implementation of loops, code blocks and decision trees. The compiler-centric transformation model minimizes the effect of legacy code migration for multimedia applications. Results are exposed for the transformation of typical DSP applications and a video transcodec MPEG-4.

As Grid technology matures more and more production Grids become available to run computationally intensive scientific applications. However, as these Grids are based on different middleware solutions interoperation between these platforms is one of the major challenges the Grid community is facing today. The P-GRADE/GEMLCA portal is a workflow oriented Grid portal that supports the execution of workflow components simultaneously on multiple Grids based on different underlying technology. Jobs can be submitted to Globus or LCG/gLite based Grids, or can be selected from the GEMLCA legacy code repository. However, as GEMLCA is implemented on top of GT4, it was capable to interact only with GT2 and GT4 based Grids until recently. Moreover, legacy codes selected from the GEMLCA repository were statically mapped to resources. This paper describes how GEMLCA has been ported to the LCG/g-Lite based EGEE infrastructure. Besides simply porting GEMLCA to another middleware it had to be made capable to interact with the EGEE broker solution. A legacy code can not only be selected from the repository, but using its legacy code interface description it is also defined which resources are capable to execute the given code. Based on this information the broker can find the most suitable resource at workflow execution. As a result of this integration the P-GRADE/GEMLCA portal is capable to interact with both Globus and LCG/g-Lite based Grids by the means of either direct or broker-based job submission, or by browsing and selecting the executable from the legacy code repository. The described work illustrates how two important components of production Grids, a legacy code solution and a Grid broker can be successfully integrated.

Scientific applications, usually written in Fortran or C, need to be adapted to work in modern environments for conducting scientific computations, which are based on web services or components. This work presents a Legacy to Grid framework (LGF) which enables semiautomatic virtualization of legacy codes as grid services. In contrast to existing work, LGF goes beyond a simple adapter-pattern approach; it follows a two-tier design in which the adaptation service layer is loosely coupled with the legacy back end layer. We present the architecture of our framework, its basic operation, and its capabilities: support for different interaction patterns with a legacy code and for computation migration to enable fault-tolerance and dynamic load balancing of legacy codes. We also present a case study of our framework's usage. We conclude with an evaluation of the impact of the two-layer architecture on the application's performance and the tradeoff between flexibility and performance by measuring the overhead of virtualization for different granularities of the legacy code.

Scientific applications, usually written in Fortran or C, need to be adapted to work in modern environments for conducting scientific computations, which are based on web services or components. This work presents a Legacy to Grid framework (LGF) which enables semiautomatic virtualization of legacy codes as grid services. In contrast to existing work, LGF goes beyond a simple adapter-pattern approach; it follows a two-tier design in which the adaptation service layer is loosely coupled with the legacy back end layer. We present the architecture of our framework, its basic operation, and its capabilities: support for different interaction patterns with a legacy code and for computation migration to enable fault-tolerance and dynamic load balancing of legacy codes. We also present a case study of our framework's usage. We conclude with an evaluation of the impact of the two-layer architecture on the application's performance and the tradeoff between flexibility and performance by measuring the overhead of virtualization for different granularities of the legacy code.

The development of distributed applications has not progressed as rapidly as its enabling technologies. In part, this is due to the difficulty of reasoning about such complex systems. One reason for the added complexity is the need for communication within modern computing systems. In contrast to sequential systems, parallel systems give rise to parallel events (communications), and the resulting uncertainty of the observed order of these events. Loosely coupled distributed systems complicate this even further by introducing the element of multiple imperfect observers of these parallel events. To address these challenges, we introduce view-centric reasoning, an approach to thinking about modern computing systems that directly supports multiple, inconsistent and imperfect views of computation. While view-centric reasoning is general enough to apply to any communication model, the focus of this paper is on computing systems that employ generative communication, a middleware-based distributed shared memory manipulated by a coordination (communication) language. In particular, we apply view-centric reasoning to tuple space based systems and the Linda coordination language. View-centric reasoning helps us resolve a potential ambiguity in the semantics of Linda predicate operations found in commercial implementations of tuple space, such as Sun's JavaSpaces and IBM's T Spaces.

The Intel Security Guard Extensions (SGX) architecture enables the abstraction of enclaved execution, using which an application can protect its code and data from powerful adversaries, including system software that executes with the highest processor privilege. While the Intel SGX architecture exports an ISA with low-level instructions that enable applications to create enclaves, the task of writing applications using this ISA has been left to the software community. We consider the problem of porting legacy applications to SGX enclaves. In the approximately four years to date since the Intel SGX became commercially available, the community has developed three different models to port applications to enclavesÐthe library OS, the library wrapper, and the instruction wrapper models. In this paper, we conduct an empirical evaluation of the merits and costs of each model. We report on our attempt to port a handful of real-world application benchmarks (including OpenSSL, Memcached, a Web server and a Python interpreter) to SGX enclaves using prototypes that embody each of the above models. Our evaluation focuses on the merits and costs of each of these models from the perspective of the effort required to port code under each of these models, the effort to re-engineer an application to work with enclaves, the security offered by each model, and the runtime performance of the applications under these models. CCS CONCEPTS • Security and privacy → Software security engineering.

The development of code for finite elements-based field computation has been going on at a pace since the 1970s, yielding code that was not put through the software lifecyclewhere code is developed through a sequential process of requirements elicitation from the user/client to design, analysis, implementation and testing (with loops going back from the second stage onwards as dissatisfactions are identified or questions arise) and release and maintenance. As a result, today we have legacy code running into millions of lines, implemented without planning and not using proper state-of-the-art software design tools. It is necessary to redo this code to exploit object oriented facilities and make corrections or run on the web with Java. Object oriented code's principal advantage is reusability. It is ideal for describing autonomous agents so that values inside a method are private unless otherwise so provided-that is encapsulation makes programming neat and less error-prone in unexpected situations. Recent advances in software make such reverse engineering/reengineering of this code into object oriented form possible. The purpose of this paper is to show how existing finite element code can be reverse/re-engineered to improve it. Taking sections of working finite element code, especially matrix computation for equation solution as examples, we put it through reverse engineering to arrive at the effective UML design by which development was done and then translate it to Java. This then is the starting point for analyzing the design and improving it without having to throw away any of the old code.

Herbert Schnädelbach hat in seinen Arbeiten die Meinung geäußert, dass die Philosophie von Hegel, als ganzheitliches Wissenssystem betrachtet, in den Verhältnissen der posthistorizistischen Aufklärung nicht mehr akzeptabel ist. Nichtsdestotrotz kann man gewisse Aspekte bzw. Fragmente dieser Philosophie seines Erachtens durchaus als interessant und diskussionsfähig betrachten. Zu denjenigen, die diese Auffassung zu teilen scheinen, gehören die beiden großen Vertreter der Hermeneutik des 20. Jahrhunderts, nämlich W. Dilthey und H.-G. Gadamer. Die Inspirationen, die die Hegelsche Lehre vom Geist für die hermeneutische Theorie von Dilthey war, sind relativ gut bekannt. Man kann sie vielleicht mit folgendem Zitat aus Diltheys posthum erschienen Werk über den Aufbau der geschichtlichen Welt in den Geisteswissenschaften zum Ausdruck bringen: »Hegel hat in Einem Begriff das Ergebnis dieser ganzen Bewegung zusammengefasst-in den des objektiven Geistes. Aber die Voraussetzungen, auf die Hegel diesen Begriff gestellt hat, können heute nicht mehr festgehalten werden. Er konstruierte die Gemeinschaften aus dem allgemeinen vernünftigen Willen. Wir müssen heute von der Realität des Lebens ausgehen; im Leben ist die Totalität des seelischen Zusammenhanges wirksam. Hegel konstruiert metaphysisch; wir analysieren das Gegebene. Und die heutige Analyse der menschlichen Existenz erfüllt uns alle mit dem Gefühl der Gebrechlichkeit, der Macht des dunklen Triebes, des Leidens an den Dunkelheiten und den Illusionen, der Endlichkeit in allem, was Leben ist, auch wo die höchsten Gebilde des Gemeinschaftsleben aus ihm entstehen. So können wir den objektiven Geist nicht aus der Vernunft verstehen, sondern müssen auf den Strukturzusammenhang der Lebenseinheiten, der sich in den Gemeinschaften fortsetzt, zurückgehen«. 1

The legacy software contains experienced and validated knowledge that is very useful. But, these legacy systems may be problematic in few aspects like compatibility, security, enhancement, complexity. Hence, software modernization is required to meet the current business needs. The existing approaches like re-factoring, re-architecture, re-engineering, white-box modernization, black-box modernization are not sufficient for handling above-mentioned problem in a cost-efficient way. The proposed approach is based on model transformations where legacy system automatically passes through different models to reach the executable code in modern technologies. In this approach, only database of legacy software is required to modernize. This approach is able to exploit the problem faced by the legacy systems as there is no availability of proper document to it. It provides a discriminative way in providing proper design document for legacy systems through model transformations.

The legacy software contains experienced and validated knowledge that is very useful. But, these legacy systems may be problematic in few aspects like compatibility, security, enhancement, complexity. Hence, software modernization is required to meet the current business needs. The existing approaches like re-factoring, re-architecture, re-engineering, white-box modernization, black-box modernization are not sufficient for handling above-mentioned problem in a cost-efficient way. The proposed approach is based on model transformations where legacy system automatically passes through different models to reach the executable code in modern technologies. In this approach, only database of legacy software is required to modernize. This approach is able to exploit the problem faced by the legacy systems as there is no availability of proper document to it. It provides a discriminative way in providing proper design document for legacy systems through model transformations.

Service-orientation views applications as orchestrations of independent software services that (1) implement functions that are reusable across many applications, (2) can be invoked remotely, and (3) are packaged to decouple potential callers from their implementation technology. As such, it enables organizations to develop quality applications faster than without services. Legacy applications are not service-oriented. Yet, they implement many reusable functions that could be exposed as services. Organizations face three main issues when re-engineering legacy application to (re)use services: (1) to mine their existing applications for reusable functions that can become services, (2) to package those functions into services, and (3) to refactor legacy applications to invoke those services to ease future maintenance. In this paper, we explore these three issues and propose research directions to address them. We choose to focus on the service-oriented re-engineering of recent legacy object-oriented applications, and more specifically, on JEE applications, for several reasons. First, we wanted to focus on architectural challenges, and thus we choose to not have to deal with programming language difference between source and target system. We chose JEE applications, in particular, because they embody the range of complexities that one can encounter in recent legacy applications, namely, multi-language systems, multi-tier applications, the reliance on external configuration files, and the reliance on frameworks and container services during runtime. These characteristics pose unique challenges for the three issues mentioned above.

My name is Cynthia Mumbo. I am now 38, I just turned 38. I've been playing basketball since I was like maybe 14, back in high school. So, when we were younger, we used to watch 'NBA Action' on Sunday afternoons, as the TV was never on during the day. We'd really look forward to getting to watch basketball. When I did get to see this, it was so exciting. Everyone wanted to go and watch 'NBA Action.' It was the coolest thing and you'd walk around with children, everyone was wearing Orlando Magic or Lakers singlets. I just got hooked up. I went to high school and I got on the hockey pitch and I saw two major injuries, and I said, 'This is not where I'm meant to be.' So, I got off to try basketball. I ran away from hockey. I got onto the basketball court and I held the ball. I threw it, well, I learned that that is called a free throw. I threw it and it went right in. So that's how I knew that I'm better on the court team. I was like, 'Oh my goodness, what are all these things I've been playing. What are all these things I've been doing?' I got hooked on basketball right from there. I played for the basketball team at school from the first year. I remember that actually, our coach had kicked me out because apparently Form Ones were not meant to get on to the court until like the second or third term. I just used to go to the court. I didn't care whether they chased me out and eventually they allowed me to play. Dr Lindsay Sarah Krasnoff So, who else was playing basketball alongside of you? You say that everyone was very keen and very popular with the NBA, but who was actually playing on the court with you? Cynthia Mumbo So, funny thing is when I was watching it, there was nowhere to play. We just used to go and watch. When I was younger, like younger than 14, it was the 'in' thing. Everyone just wanted to go and watch the NBA. It was cool. The older kids, the kids were about 16, those who were about maybe 18, 19. They were knew a little bit more about the game. We didn't have, I didn't have access to a basketball court until I got into high school. So, I started playing basketball with my high school mates. Apart from that, there was never a basketball court anywhere near me or near us. It was really just a cool thing.

COBOL, a traditional language, has been presented for more than 50 years. There are at least 100 billion lines of legacy codes written in COBOL up to now. An effective way to maintain these legacy codes is to translate them into modern languages, such as Java. While translating, it is a key-step to eliminate 'GOTO' and 'PERFORM' and their compound control structures in COBOL programs. A method which uses 'switch' and 'while' statements is proposed in this paper instead of 'GOTO' and 'PERFORM' and their compound control structures. It preserves the readability because the target Java program has the similar control structures. The code size of the target program expands only 2 times in average. This method is applied in the 'C2J translation system'. It is proved sound and effective since 4 million lines of real COBOL program have been translated and its target program has passed the test.

In this paper we present our experiences developing two distributed computing applications on NT. In both examples a legacy application is ported from Unix to NT and is then further developed to be a distributed application within the NT environment. We shall present two different approaches to managing the remote execution of tasks. One is a port of a serial vibroacoustic analysis code called PAFEC VibroAcoustic and the other is the parallelisation of the non-linear analysis modules of the LUSAS FE analysis package. We shall show in these two projects that it is technically possible to carry out scientific computing on a distributed NT resource

Source-to-source translation of programs from one high level language to another has been shown to be an effective aid to programming in many cases. By the use of this approach, it is sometimes possible to produce software more cheaply and reliably. However, the full potential of this technique has not yet been realized. It is proposed to make sourceto-source translation more effective by the use of abstract languages, which are imperative languages with a simple syntax and semantics that facilitate their translation into many different languages. By the use of such abstract languages and by translating only often-used fragments of programs rather than whole programs, the need to avoid writing the same program or algorithm over and over again in different languages can be reduced. It is further proposed that programmers be encouraged to write often-used algorithms and program fragments in such abstract languages. Libraries of such abstract programs and program fragments can then be constructed, and programmers can be encouraged to make use of such libraries by translating their abstract programs into application languages and adding code to join things together when coding in various application languages. This approach can also improve program reliability, because it is only necessary to verify the abstract programs once instead of verifying them separately in each application language. Also, this approach makes it possible to generate code faster than programming from scratch each time. This approach is compared to the use of libraries and to other methods in current use for communication between programming languages and translation between languages.

Refactoring can be an important ingredient in the stratcgy for development and evolution of complex telecommunications software systems. Refactoring is o n e way t o reuse and extend a successful software system. This article will present some design tactics that will assist a development team when thcy choose evolution from an existing software system over building a completely new systcm from the ground up. Strictly speaking, t h e refactoring proccss changes only the internal design of the software. Refactoring does not add any new functionality. However, the goal of refactoring work is to pave the way for the software to be modified and extended morc easily. T h e simplest example of redesign is the creation of simple "wrapper classes" that contain groups of functions extracted from t h e lcgacy code. More complex design patterns are also useful when attempting to improve the design. Developers usually divide the redesign work into stages so that each stage can be implemcnted and tested separately. This article describes a real-world example of this approach that shows how refactoring improved the design of a wireless base station controller product. aa

As the volume of legacy software grows, how have we grown in our ability to leverage this legacy-or, for that matter, is it worth the effort? Is legacy software a hoard of useful information and behavior-or is it a ball and chain, something you should cut loose if you want to make progress? Legacy constraints often seem immense and burdensome-but, do they always need to be? Is object-oriented legacy software spaghetti code-or is it more like ravioli? Do agile methods embrace or reject the use of the legacy?

Among the many challenges faced by businesses that maintain legacy software systems is the integration of those systems with external data sources, which are often other software systems developed and maintained by otherwise unrelated entities. Leveraging service oriented-architecture (SOA) provides a method by which the business value of a legacy system can be extended without the expensive alternative of reengineering or of complete replacement of the software. This paper describes a particular implementation that used a SOA approach to enhance and extend the functionality of a mature, complex multi-channel commerce enterprise system. The implementation linked the legacy enterprise system of a multi-channel merchant with that of an international shipping company that provides a service for electronic shipping label requests. The goal was to further automate the process of shipping and tracking of purchased products returned by customers of the merchant.

This paper presents a case study of analyzing a legacy PL/1 ecosystem that has grown for 40 years to support the business needs of a large banking company. In order to support the stakeholders in analyzing it we developed St1-PL/1-a tool that parses the code for association data and computes structural metrics which it then visualizes using topdown interactive exploration. Before building the tool and after demonstrating it to stakeholders we conducted several interviews to learn about legacy ecosystem analysis requirements. We briefly introduce the tool and then present results of analysing the case study. We show that although the vision for the future is to have an ecosystem architecture in which systems are as decoupled as possible the current state of the ecosystem is still removed from this. We also present some of the lessons learned during our experience discussions with stakeholders which include their interests in automatically assessing the quality of the legacy code.

Web services, together with service-oriented architectures, are promising integration technology to facilitate legacy system Webification and evolution. However, a service-oriented re-engineering process is still essential for legacy systems to survive in the service-oriented computing environment. In this service-oriented re-engineering process, understanding and reusing object-oriented code turn to be important activities. In this paper, we proposed a comprehensive approach to support the extraction and integration of reusable object-oriented legacy code. In the extraction phase, formal concept analysis, which is a general and flexible technique for recovering structural design information, and inter-procedural program slicing are adopted as main reverse engineering techniques to recover reusable object-oriented code. In the integration phase, service packaging processes are presented in details. Our approach produces extracted components with core legacy object-oriented code function in Web services by wrapping underlying computing models with XML.

Many legacy systems were developed in COBOL, which still play an important role in business. It is an unavoidable issue for organisations to maintain or replace these COBOL systems. In order to make a better use of these legacy COBOL systems, research on modelling and reusing COBOL code are significant. This paper presents an approach to modelling legacy COBOL code with UML collaboration diagrams via a Wide Spectrum Language (WSL). Firstly, legacy COBOL code is transferred into WSL, which is an intermediate language. Secondly, WSL representation is restructured to eliminate GOTO statements. Then an object concept model is created by operating WSL representation. Finally, the collaboration diagrams are constructed based on this object concept model. These collaboration diagrams express the dynamic behaviour of the system, using the structural class and relationship elements of the model, and facilitate engineers to understand and reuse legacy COBOL code.

Model-driven approaches as well as migration projects rely on a strong tool support. As part of the SOAMIG project, a tool suite has been developed, supporting the model-driven migration of legacy Java and COBOL systems towards Service-oriented Architectures (SOAs). The tool suite integrates a global repository (representing business processes, code and architecture) and capabilities for (i) parsing legacy artifacts (code and project specific architecture constructs), (ii) analyzing legacy code (static and dynamic analysis) and (iii) transforming artifacts.

In reengineering, legacy systems have to be analyzed from different viewpoints. Models dealing with certain aspects of a system are used for that purpose, most of which are generated by fact extractors and parsers. Since all of those models describe certain aspects of the same system, they have to be integrated with each other to allow a comprehensive analysis of the system as a whole. This paper presents an approach using dynamic analysis to identify and manifest relationships between static model elements. It exemplifies the approach by integrating a business process model with a source code model.

Migrating legacy systems towards Service-Oriented Architectures requires the identification of legacy code that is able to implement the new services. This paper proposes an approach combining dynamic analysis and data mining techniques to map legacy code to business processes and to identify code for service implementations based on this mapping. Validating the clustering solution in a first case study resulted in values of 70,6% in precision and 83,5% in recall.

Riley is currently focusing on fi nishing his undergraduate courses. His interests involve amateur radio, electronics and the outdoors. Riley also likes repairing broken things. G eorge Mesina received a Ph.D. in Applied Mathematics from the University of Pittsburgh in 1988. He then joined the Idaho National Laboratory (INL) and works in computational fl uid dynamics and thermal hydraulics and has over 30 publications in these areas. In 1993, he joined the RELAP5 Development Team and invented the BPLU algorithm for vector-parallel solution of linear equations and implemented it in RELAP5; it allowed RELAP5 to run 5 times faster on vector-parallel supercomputers on the AP600 nuclear power plant benchmark. In 1995, Dr. Mesina won a Small Business Innovative Research grant with Computer Simulation and Analysis for distributed computing via the Parallel Virtual Machine protocol. From 1996-1997 he was PI for the Real-time RELAP5 Cooperative Research and Development Agreement that created the RELAP5-RT simulator version, licensed in 1997 and 1999, that is still being sold for use on nuclear power plant training simulators. From 1998-2000 he was PI and lead developer of the RELAP5 Graphical User Interface project that automatically generates a 3D rendering of a RELAP5 input model. Since then George has become code architect of RELAP5-3D. He has also been PI and lead developer of numerous projects including: RELAP5-3D parallelization for share-memory multiprocessors, RELAP5-3D code restructuring, and the 4.5 year FORTRAN 95 conversion project. Apart from his work with RELAP5, Dr. Mesina has chaired numerous conference sessions, served on many INL committees and is currently an INL Subject Matter Expert for Mathematics and the FORTRAN language. He has developed algorithms and implemented them as programs including: a FORTRAN statistics program for the Probability Risk Assessment group and a C++ program for doing least squares curve fi ts through sensor data for the INL Advanced Test Reactor.

RELAP5-3D is a nuclear power plant code used worldwide for safety analysis, design, and operator training. In keeping with ongoing developments in the computing industry, we have re-architected the code in the FORTRAN 95 language [2], the current, fully-available, ANSI standard FORTRAN language. These changes include a complete reworking of the database and conversion of the source code to take advantage of new constructs. The improvements and impacts to the code are manifold. It is a completely machine-independent code that produces machine independent fluid property and plot files and expands to the exact size needed to accommodate the user's input. Runtime is generally better for larger input models, many prior user-reported problems have been resolved, and the program is better tested. Other impacts of code reformulation are improved code readability, reduced maintenance and development time, increased adaptability to new computing platforms, and increased code longevity. Comparison between the pre-and post-conversion code are made on the basis of programming metrics and code performance.

Several approaches have already been proposed to extract both business processes and business rules from a legacy source code. These approaches consider static source code analysis for the extraction procedure. However, business processes have components that can not be directly extracted by static analysis (i.e., participants, responsibilities, and concurrent activities). Moreover, well-known static analysis algorithms do not support the incremental extraction of information from the legacy code. Large legacy systems can benefit from an incremental analysis strategy in order to provide iterative information extraction as well as to achieve partial results much earlier. This paper discusses a new approach for business knowledge extraction from legacy systems. The approach considers an incremental process mining technique to extract business process structures and the business rules associated to it. Discovery results can be used in various ways by business analysts and software architects, e.g. documentation of legacy systems or for re-engineering purposes.

Grid Computing has, over the past few years, matured sufficiently to make it a viable solution for realworld problems. However, there are many different toolkits today that allow to build a Grid environment. And while this wealth of different solutions may offer techniques applicable to the widest possible range of computational problems, their very availability directly contradicts the inherent promise of the "World Wide Grid" to offer a compatible and standardised infrastructure. The European Union project EGEE 1 aims at a consolidation of existing efforts and will assist in the deployment of the resulting Grid middleware gLite by offering support and training to new users, both in academia and industry. This paper introduces the historical development and present scope of European Grid projects and middlewares leading up to EGEE. Beyond its European scope, the paper tries to clarify their relationships to worldwide initiatives and to give an insight into the lessons learned during the development. The paper concludes with the introduction of a national Grid deployment project-the German D-Grid initiative. 1 Overview 2007 will see the advent of the Large Hadron Collider 2 (R. Ostojic 2001), a particle accelerator built in the tunnel of the now decommissioned Large Electron Positron Collider (LEP) at CERN 3 near Geneva, Switzerland. In contrast to LEP, LHC will collide protons with protons or, alternatively, heavy ions, such as lead. As a result of the collision, the kinetic energy and rest-mass of these particles is transformed into other particles that can be detected in large detector systems 4 built around the interaction points. One collision is usually referred to as an "event". The peculiarities of these events, together with high particle-energies and-beam intensities, lead to data rates unprecedented by todays most modern particle physics experiments. The estimated amount of data emanating from all four LHC experiments,

The volatile IT industry often tempts companies to replace legacy information systems with new ones. However, legacy systems cannot always be completely discarded because they gradually store a significant amount of valuable business knowledge as a result of progressive maintenance over time. Most migration techniques are proposed and applied in an ad hoc way. As a result, most migration techniques have a lack of automation and formalization, which makes it difficult to reuse such techniques to large, complex legacy information systems. This paper introduces MIMOS, a third-year project aimed at developing a methodological and technological modernization framework to facilitate the migration of legacy systems based on high-level design models. The work in progress during the first year mainly focused on the definition of a business process mining technique to retrieve the business knowledge embedded in source code so that it can be reused in the target system.

How to cite Complete issue More information about this article Journal's homepage in redalyc.org Scientific Information System Network of Scientific Journals from Latin America, the Caribbean, Spain and Portugal Non-profit academic project, developed under the open access initiative 104

characteristics, necessary to build on its concrete implementation. So, starting from the existent tuple spaces infrastructure TuCSoN, we realize a first biochemical released(BioTuCSoN), reifying the principal concepts acquired by the previous studies. Comparative performance tests between TuCSoN and BioTuCSoN are, then, provided, in order to prove respective advantages in different situations. Our work ends evaluating a case study that points out the capabilities of the realized biochemical technology. The thesis is organised as follows. In chapter one we present the SAPERE project, first through general considerations and then analysing, carefully, its structure and model. Chapter two provides a discussion on biochemical tuple spaces, analysing some background researches and, then, deducing from them essential abstractions and features. Chapter three describes TuCSoN technology that constitutes the basis from which we start to define BioTuCSoN. The related work process is explained in chapter four. Finally, chapter five shows an interesting case study, highlighting the results achieved by means of the weighted probabilistic behaviour of BioTuCSoN.

The central block of the Grid Empowered Molecular Simulator GEMS was extended to Molecular Dynamics calculations by implementing the GROMACS code. The Grid porting was carried out using the P-GRADE Portal tool. The performances achieved using this approach were measured and compared with those of other approaches better exploiting the mixed nature of the computing resources available on the Grid. The work was completed by implementing some Grid based graphical rendering utilities and extending the study to another Molecular Dynamics package. A. Costantini et al.

As unidades de processamento gráfico (GPUs) são arquiteturas populares e oferecem paralelismo massivo a baixo custo, porém, sua utilização eficiente é um desafio. Benchmarks são uma forma de suportar a pesquisa de GPUs. NAS Parallel Benchmarks (NPB) é um consolidado conjunto de benchmarks baseado em computações de dinâmica de fluidos [Bailey et al. 1994] (CFD) que está recebendo atenção no contexto de GPUs com artigos publicados recentemente [Do et al. 2019, d. Araujo et al. 2020].

Parallelism has become one of the most extended paradigms used to improve performance. However, it forces software developers to adapt applications and coding mechanisms to exploit the available computing devices. Legacy source code needs to be rewritten to take advantage of multi-core and many-core computing devices. Writing parallel applications in a traditional way is hard, expensive, and time consuming. Furthermore, there is often more than one possible transformation or optimization that can be applied to a single piece of legacy code. Therefore many parallel versions of the same original sequential code need to be considered. In this paper, we describe an automatic parallel source code generation workflow (REWORK) for parallel heterogeneous platforms. REWORK automatically identifies promising kernels on legacy C++ source code and generates multiple specific versions of kernels for improving C++ applications, selecting the most adequate version based on both static source code and target platform characteristics.

There is no doubt that the systems' integration is one of the most important and complicated tasks in software filed especially for complex applications like banking systems. Complexity in integrating banking systems often comes from continues changes in both technical and business features provided by them to meet customer needs. Banking systems always come from different software vendors which mean using platforms and different design and architecture patterns, and this for sure adds extra complexity for integrating ...

Control-flow integrity (CFI) is a general defense against codereuse exploits that currently constitute a severe threat against diverse computing platforms. Existing CFI solutions (both in software and hardware) suffer from shortcomings such as (i) inefficiency, (ii) security weaknesses, or (iii) are not scalable. In this paper, we present a generic hardwareenhanced CFI scheme that tackles these problems and allows to enforce diverse CFI policies. Our approach fully supports multi-tasking, shared libraries, prevents various forms of code-reuse attacks, and allows CFI protected code and legacy code to co-exist. We evaluate our implementation on SPARC LEON3 and demonstrate its high efficiency.

Code-reuse attacks like return-oriented programming (ROP) pose a severe threat to modern software on diverse processor architectures. Designing practical and secure defenses against code-reuse attacks is highly challenging and currently subject to intense research. However, no secure and practical system-level solutions exist so far, since a large number of proposed defenses have been successfully bypassed. To tackle this attack, we present HAFIX (Hardware-Assisted Flow Integrity eXtension), a defense against code-reuse attacks exploiting backward edges (returns). HAFIX provides fine-grained and practical protection, and serves as an enabling technology for future control-flow integrity instantiations. This paper presents the implementation and evaluation of HAFIX for the Intel Siskiyou Peak and SPARC embedded system architectures, and demonstrates its security and efficiency in code-reuse protection while incurring only 2% performance overhead.

Legacy software systems present a high level of entropy combined with imprecise documentation. This makes their maintenance more difficult, more time consuming, and costlier. In order to address these issues, many organizations have been migrating their legacy systems to emerging technologies. In this paper, we describe a computer-supported approach aimed at supporting the migration of procedural software systems to the object-oriented (OO) technology. Our approach is based on the automatic formation of concepts, and uses information extracted directly from code to identify objects. The approach tends, thus, to minimize the need for domain application experts.

Expert knowledge from many disciplines is frequently embodied in stand-alone codes used to solve particular problems. Codes from various disciplines can be composed into cooperative ensembles that can answer questions larger than any solitary code can. These multi-code compositions are called multidisciplinary applications and are a growing area of research. To support the integration of existing codes into multidisciplinary applications, we have constructed the Multidisciplinary Application Runtime System (MARS). MARS supports legacy modules, heterogeneous execution environments, conditional execution flows, dynamic module invocation and realignment, runtime binding of output data paths, and a simple specification language to script module actions. instilled in me the strong ethic that has carried me thus far, and continues to carry me into the future. Thank you both. iv Acknowledgements There are too many people to thank without a second volume as large as this one. However, I wou...

Many organisations are migrating towards object-oriented technology. However, owing to the business value of legacy software, new object-oriented development has to be weighed against salvaging strategies. The incremental migration of procedurally oriented systems to object-oriented platforms seems to be a feasible approach, although it must be considered as risky as redevelopment. This approach uses reverse engineering activities to abstract an object-oriented model from legacy code. The paper presents a method for decomposing legacy systems into objects. The identi®cation of objects is centred around persistent data stores, such as ®les or tables in the database, while programs and routines are candidates for implementing the object methods. Associating the methods to the objects is achieved by optimising selected object-oriented design metrics. The rationale behind this choice is that the object-oriented decomposition of a legacy system should not result in a poor design, as this would make the re-engineered system more dicult to maintain.

Software source text is the raw material of program understanding and transformation systems. In order to share the results of source analyses, both between phases of a design recovery process, and between tools and systems in different processes, a source text interchange format is needed. This paper describes a simple technique, 'source factoring', by which a common structural decomposition of source text can address the many issues of preprocessing, macro processing, lexical analysis, design recovery, and automated transformation. Above all, source factorization allows the results of design analysis to be attached to source, and the results of source transformation to be reinstalled cleanly into the code base. This view of source text underlies the architecture of a successful software maintenance system which has processed billions of lines of legacy code in all major programming languages.

COBOL, a traditional language, has been presented for more than 50 years. There are at least 100 billion lines of legacy codes written in COBOL up to now. An effective way to maintain these legacy codes is to translate them into modern languages, such as Java. While translating, it is a key-step to eliminate 'GOTO' and 'PERFORM' and their compound control structures in COBOL programs. A method which uses 'switch' and 'while' statements is proposed in this paper instead of 'GOTO' and 'PERFORM' and their compound control structures. It preserves the readability because the target Java program has the similar control structures. The code size of the target program expands only 2 times in average. This method is applied in the 'C2J translation system'. It is proved sound and effective since 4 million lines of real COBOL program have been translated and its target program has passed the test.

There is no doubt that the systems' integration is one of the most important and complicated tasks in software filed especially for complex applications like banking systems. Complexity in integrating banking systems often comes from continues changes in both technical and business features provided by them to meet customer needs. Banking systems always come from different software vendors which mean using platforms and different design and architecture patterns, and this for sure adds extra complexity for integrating ...