Spelling suggestions: "subject:"8oftware aigration"" "subject:"8oftware amigration""
1 |
Software Evolution in the context of .Net FrameworkWalid, Rohaimi January 2007 (has links)
<p>This paper discusses the process of software evolution and especially software migration in the context of .NET Technologies. Actually most of the companies that uses legacy systems implemented with procedural languages as C, Visual Basic and so on, meet some problems when new requirement specifications have to be integrated.</p><p>One possibility to deal with this situation is to choose a good migration strategy from these legacy systems towards new Object Oriented design.</p><p>There are some migration processes that enable the fulfilment of this task but most of the time theses processes cannot be applied directly without any modification.</p><p>This report presents a migration strategy and migration process applied for a real case of an application in a company. The New Object Oriented design of the application and the result are discussed in the following sections of this document.</p>
|
2 |
Software Evolution in the context of .Net FrameworkWalid, Rohaimi January 2007 (has links)
This paper discusses the process of software evolution and especially software migration in the context of .NET Technologies. Actually most of the companies that uses legacy systems implemented with procedural languages as C, Visual Basic and so on, meet some problems when new requirement specifications have to be integrated. One possibility to deal with this situation is to choose a good migration strategy from these legacy systems towards new Object Oriented design. There are some migration processes that enable the fulfilment of this task but most of the time theses processes cannot be applied directly without any modification. This report presents a migration strategy and migration process applied for a real case of an application in a company. The New Object Oriented design of the application and the result are discussed in the following sections of this document.
|
3 |
Evolution of Security in Automated Migration ProcessesTayefeh Morsal, Seyed Parsa January 2022 (has links)
As users’ requirements change in today’s fast-paced business market, computer software has to adapt to new hardware, technologies and requirements to keep up with the trend. Therefore, to avoid depreciation and obsolescence, which can have detrimental effects on a product, software needs to be constantly maintained and, when passed a certain point in its lifecycle, needs to be migrated or re-developed from scratch. Automated migration enables software vendors to decrease the cost of the migration process by source code generation. However, as security is a crucial requirement in any system, it is not guaranteed that the previously satisfied security requirements are satisfied in the migrated software. Therefore, it is critical to study the evolution of security throughout the automated migration process to predict where new security vulnerabilities may emerge and to understand the scale on which the security is affected. / Thesis / Master of Applied Science (MASc)
|
4 |
A wide spectrum type system for transformation theoryLadkau, Matthias January 2009 (has links)
One of the most difficult tasks a programmer can be confronted with is the migration of a legacy system. Usually, these systems are unstructured, poorly documented and contain complex program logic. The reason for this, in most cases, is an emphasis on raw performance rather than on clean and structured code as well as a long period of applying quick fixes and enhancements rather than doing a proper software reengineering process including a full redesign during major enhancements. Nowadays, the old programming paradigms are becoming an increasingly serious problem. It has been identified that 90% of the costs of a typical software system arise in the maintenance phase. Many companies are simply too afraid of changing their software infrastructure and prefer to continue with principles like "never touch a running system". These companies experience growing pressure to migrate their legacy systems onto newer platforms because the maintenance of such systems is expensive and dangerous as the risk of losing vital parts of sources code or its documentation increases drastically over time. The FermaT transformation system has shown the ability to automatically or semi-automatically restructure and abstract legacy code within a special intermediate language called WSL (Wide Spectrum Language). Unfortunately, the current transformation process only supports the migration of assembler as WSL lacks the ability to handle data types properly. The data structures in assembler are currently directly translated into C data types which involves many assumptional “hard coded” conversions. The absence of an adequate type system for WSL caused several flaws for the whole transformation process and limits its abilities significantly. The main aim of the presented research is to tackle these problems by investigating and formulating how a type system can contribute to a safe and reliable migration of legacy systems. The described research includes the definition of key aspects of type related problems in the FermaT migration process and how to solve them with a suitable type system approach. Since software migration often includes a change in programming language the type system for WSL has to be able to support various type system approaches including the representation of all relevant details to avoid assumptions. This is especially difficult as most programming languages are designed for a special purpose which means that their possible programming constructs and data types differ significantly. This ranges from languages with simple type systems whose program sare prone to unintended side-effects, to languages with strict type systems which are constrained n their flexibility. It is important to include as many type related details as necessary to avoid making assumptions during language to language translation. The result of the investigation is a novel multi layered type system specifically designed to satisfy the needs of WSL for a sophisticated solution without imposing too many limitations on its abilities. The type system has an adjustable expressiveness, able to represent a wide spectrum of typing approaches ranging from weak typing which allows direct memory access and down casting, via very strict typing with a high diversity of data types to object oriented typing which supports encapsulation and data hiding. Looking at the majority of commercial relevant statically typed programming languages, two fundamental properties of type strictness and safety can be identified. A type system can be either weakly or strongly typed and may or may not allow unsafe features such as direct memory access. Each layer of the Wide Spectrum Type System has a different combination of these properties. The approach also includes special Type System Transformations which can be used to move a given WSL program among these layers. Other emphasised key features are explicit typing and scalability. The whole approach is based on a sound mathematical foundation which assures correctness and integrates seamlessly into the present mathematical definition of WSL. The type system is formally introduced to WSL by constructing an attribute grammar for the language. Type checking and type inference are used to annotate the Abstract Syntax Tree of a given WSL program with type derivations which can be used to reveal and indicate possible typing errors or to infer types if the program did not feature explicit type declarations in the first place. Notable in this approach is also the fact that object orientation is introduced to a procedural programming language without the introduction of new semantics. It is shown that object orientation can be introduced just by adjusting type checking rules and adding some syntactical notations. The approach was implemented and tested on two case studies. The thesis describes and discusses both cases in detail and shows how a migration which ignores type systems could accidentally introduce errors due to assumptions during translation. Both case studies use all important aspects of the approach, Including type transformations and object identification. The thesis finalises by summarising the whole work, identifying limitations, presenting future perspectives and drawing conclusions
|
5 |
Struts2JSF: Framework Migration in J2EE Using Framework Specific Modeling LanguagesCheema, Aseem Paul Singh January 2007 (has links)
Java 2 Enterprise Edition is a portable, robust, scalable and secure platform for enterprise
software development based on Java technologies, and embraces open standards through
the Java Community Process (JCP). J2EE development is not very productive because of
the complexity of the platform and the lack of good tool support. Object-Oriented Frame-
works are a reliable design and code reuse approach. Many frameworks have emerged
since J2EE’s release to ease development. Struts has become the de-facto standard, while
JavaServer Faces (JSF) is a new framework, which has been included in the J2EE spec-
ification and hence standardized. Both Struts and JSF frameworks are based on Model-
View-Controller design pattern. JSF takes a similar approach to Struts for the controller
component, but adds to it by providing user interface components with server-side state
for the view component.
This work deals with the problem of migrating an application based on the Struts frame-
work to the new JSF framework. The software migration task is divided into view and con-
troller migration. Controller migration is semi-automated using Antkiewicz’s Framework-
Specific Modeling Languages (FSML) approach. Guidelines are provided for view migra-
tion, which boils down to the problem of componentization. JSF and Struts frameworks
can also be used together where JSF supports the view component while Struts supports
the controller component. Merits and demerits of this approach are also discussed.
|
6 |
Struts2JSF: Framework Migration in J2EE Using Framework Specific Modeling LanguagesCheema, Aseem Paul Singh January 2007 (has links)
Java 2 Enterprise Edition is a portable, robust, scalable and secure platform for enterprise
software development based on Java technologies, and embraces open standards through
the Java Community Process (JCP). J2EE development is not very productive because of
the complexity of the platform and the lack of good tool support. Object-Oriented Frame-
works are a reliable design and code reuse approach. Many frameworks have emerged
since J2EE’s release to ease development. Struts has become the de-facto standard, while
JavaServer Faces (JSF) is a new framework, which has been included in the J2EE spec-
ification and hence standardized. Both Struts and JSF frameworks are based on Model-
View-Controller design pattern. JSF takes a similar approach to Struts for the controller
component, but adds to it by providing user interface components with server-side state
for the view component.
This work deals with the problem of migrating an application based on the Struts frame-
work to the new JSF framework. The software migration task is divided into view and con-
troller migration. Controller migration is semi-automated using Antkiewicz’s Framework-
Specific Modeling Languages (FSML) approach. Guidelines are provided for view migra-
tion, which boils down to the problem of componentization. JSF and Struts frameworks
can also be used together where JSF supports the view component while Struts supports
the controller component. Merits and demerits of this approach are also discussed.
|
7 |
From monolithic architectural style to microservice one : structure-based and task-based approaches / Du style architectural monolithique vers le style microservice : approches basées sur la structure et sur les tâchesSelmadji, Anfel 03 October 2019 (has links)
Les technologies logicielles ne cessent d'évoluer pour faciliter le développement, le déploiement et la maintenance d'applications dans différents domaines. En parallèle, ces applications évoluent en continu pour garantir une bonne qualité de service et deviennent de plus en plus complexes. Cette évolution implique souvent des coûts de développement et de maintenance de plus en plus importants, auxquels peut s'ajouter une augmentation des coûts de déploiement sur des infrastructures d'exécution récentes comme le cloud. Réduire ces coûts et améliorer la qualité de ces applications sont actuellement des objectifs centraux du domaine du génie logiciel. Récemment, les microservices sont apparus comme un exemple de technologie ou style architectural favorisant l'atteinte de ces objectifs.Alors que les microservices peuvent être utilisés pour développer de nouvelles applications, il existe des applications monolithiques (i.e., monolithes) cons-truites comme une seule unité et que les propriétaires (e.g., entreprise, etc.) souhaitent maintenir et déployer sur le cloud. Dans ce cas, il est fréquent d'envisager de redévelopper ces applications à partir de rien ou d'envisager une migration vers de nouveaux styles architecturaux. Redévelopper une application ou réaliser une migration manuellement peut devenir rapidement une tâche longue, source d'erreurs et très coûteuse. Une migration automatique apparaît donc comme une solution évidente.L'objectif principal de notre thèse est de contribuer à proposer des solutions pour l'automatisation du processus de migration d'applications monolithiques orientées objet vers des microservices. Cette migration implique deux étapes : l'identification de microservices et le packaging de ces microservices. Nous nous focalisons sur d'identification en s'appuyant sur une analyse du code source. Nous proposons en particulier deux approches.La première consiste à identifier des microservices en analysant les relations structurelles entre les classes du code source ainsi que les accès aux données persistantes. Dans cette approche, nous prenons aussi en compte les recommandations d'un architecte logiciel. L'originalité de ce travail peut être vue sous trois aspects. Tout d'abord, les microservices sont identifiés en se basant sur l'évaluation d'une fonction bien définie mesurant leur qualité. Cette fonction repose sur des métriques reflétant la "sémantique" du concept "microservice". Deuxièmement, les recommandations de l'architecte logiciel ne sont exploitées que lorsqu'elles sont disponibles. Enfin, deux modèles algorithmiques ont été utilisés pour partitionner les classes d'une application orientée objet en microservices : un algorithme de regroupement hiérarchique et un algorithme génétique.La deuxième approche consiste à extraire à partir d'un code source orienté objet un workflow qui peut être utilisé en entrée de certaines approches existantes d'identification des microservices. Un workflow décrit le séquencement de tâches constituant une application suivant deux formalismes: un flot de contrôle et/ou un flot de données. L'extraction d'un workflow à partir d'un code source nécessite d'être capable de définir une correspondance entre les concepts du mon-de objet et ceux d'un workflow.Pour valider nos deux approches, nous avons implémenté deux prototypes et mené des expérimentations sur plusieurs cas d'étude. Les microservices identifiés ont été évalués qualitativement et quantitativement. Les workflows obtenus ont été évalués manuellement sur un jeu de tests. Les résultats obtenus montrent respectivement la pertinence des microservices identifiés et l'exactitude des workflows obtenus. / Software technologies are constantly evolving to facilitate the development, deployment, and maintenance of applications in different areas. In parallel, these applications evolve continuously to guarantee an adequate quality of service, and they become more and more complex. Such evolution often involves increased development and maintenance costs, that can become even higher when these applications are deployed in recent execution infrastructures such as the cloud. Nowadays, reducing these costs and improving the quality of applications are main objectives of software engineering. Recently, microservices have emerged as an example of a technology or architectural style that helps to achieve these objectives.While microservices can be used to develop new applications, there are monolithic ones (i.e., monoliths) built as a single unit and their owners (e.g., companies, etc.) want to maintain and deploy them in the cloud. In this case, it is common to consider rewriting these applications from scratch or migrating them towards recent architectural styles. Rewriting an application or migrating it manually can quickly become a long, error-prone, and expensive task. An automatic migration appears as an evident solution.The ultimate aim of our dissertation is contributing to automate the migration of monolithic Object-Oriented (OO) applications to microservices. This migration consists of two steps: microservice identification and microservice packaging. We focus on microservice identification based on source code analysis. Specifically, we propose two approaches.The first one identifies microservices from the source code of a monolithic OO application relying on code structure, data accesses, and software architect recommendations. The originality of our approach can be viewed from three aspects. Firstly, microservices are identified based on the evaluation of a well-defined function measuring their quality. This function relies on metrics reflecting the "semantics" of the concept "microservice". Secondly, software architect recommendations are exploited only when they are available. Finally, two algorithmic models have been used to partition the classes of an OO application into microservices: clustering and genetic algorithms.The second approach extracts from an OO source code a workflow that can be used as an input of some existing microservice identification approaches. A workflow describes the sequencing of tasks constituting an application according to two formalisms: control flow and /or data flow. Extracting a workflow from source code requires the ability to map OO conceptsinto workflow ones.To validate both approaches, we implemented two prototypes and conducted experiments on several case studies. The identified microservices have been evaluated qualitatively and quantitatively. The extracted workflows have been manually evaluated relying on test suites. The obtained results show respectively the relevance of the identified microservices and the correctness of the extracted workflows.
|
8 |
Migration des applications orientées-objet vers celles à base de composants / Migrating Object Oriented Applications into Component-Based onesAl Shara, Zakarea 17 November 2016 (has links)
Les applications orientées objet de tailles significatives ont des dépendances complexes et nombreuses, et généralement ne disposent pas d'architectures logicielles explicites. Par conséquent, elles sont difficiles à maintenir, et certaines parties de ces applications sont difficiles à réutiliser. Le paradigme de développement à base de composants est né pour améliorer ces aspects et pour soutenir la maintenabilité et la réutilisation efficaces. Il offre une meilleure compréhensibilité à travers une vue d'architecture de haut niveau. Ainsi, la migration des applications orientées objet à celles à base de composants contribuera à améliorer ces caractéristiques, et de soutenir l'évolution des logiciels et la future maintenance.Dans cette thèse, nous proposons une approche pour transformer automatiquement les applications orientées objet à celles à base de composants. Plus particulièrement, l'entrée de l'approche est le résultat fourni par la récupération de l'architecture logicielle: une description de l'architecture à base de composants. Ainsi, notre approche transforme le code source orienté objet afin de produire des composants déployables. Nous nous concentrons sur la transformation des dépendances orientées objet en celles basées sur les interfaces. De plus, nous passons du concept d'objet au concept d'instance d'un composant. En outre, nous fournissons une approche de transformation déclarative en utilisant des langages dédiés. Nous démontrons notre approche sur de nombreux modèles de composants bien connus. / Large object-oriented applications have complex and numerousdependencies, and usually do not have explicitsoftware architectures. Therefore they are hard to maintain, and parts of themare difficult to reuse. Component-based development paradigm emergedfor improving these aspects and for supporting effectivemaintainability and reuse. It provides better understandabilitythrough a high-level architecture view of the application. Thus, migrating object-oriented applications to component-based ones will contribute to improve these characteristics, and support software evolution and future maintenance.In this dissertation, we propose an approach to automatically transform object-oriented applications tocomponent-based ones. More particularly, the input of the approach isthe result provided by software architecture recovery: acomponent-based architecture description. Then, our approachtransforms the object-oriented source code in order to producedeployable components. We focus on transforming object-oriented dependencies into interface-based ones. Moreover, we move from the concept of object to the concept of component instance. Furthermore, we provide a declarative transformation approach using domain-specific languages. We demonstrate our approach on many well-known component models.
|
Page generated in 0.3797 seconds