Global ETD Search

21	Uma abordagem orientada a modelos para reutilização de software / A model-driven software reuse approach Daniel Lucredio 17 July 2009 (has links) A reutilização de software busca aumentar a qualidade e produtividade no desenvolvimento de software, evitando a duplicação do esforço e reaproveitando o máximo possível das experiências de projetos passados. Apesar de simples, esta idéia não é facilmente colocada em prática, principalmente de maneira sistemática e controlada. Técnicas de engenharia de domínio e linhas de produtos de software buscam facilitar esta tarefa, porém ainda existem outros fatores que dificultam a adoção da prática da reutilização. Entre estes, destacam-se os problemas inerentes ao desenvolvimento de software da maneira como é conduzido atualmente, baseado em código-fonte. Estes problemas têm suas origens na crescente demanda por software cada vez mais complexo e afetam negativamente a capacidade de reutilizar software. O desenvolvimento orientado a modelos surge como uma alternativa atraente neste cenário, elevando a importância de modelos dentro do ciclo de vida do software, incorporando-os como parte integrante do produto final por meio de técnicas de modelagem e geração de código. Com isto, parte da complexidade do software fica escondida dentro dos geradores, protegendo os desenvolvedores, reduzindo a incidência de erros, aumentando a produtividade, qualidade, interoperabilidade e manutenibilidade dos artefatos produzidos. Nesta dissertação defende-se a tese de que o desenvolvimento orientado a modelos pode efetivamente aumentar e/ou melhorar a reutilização de software, e que para isso ela deve ser tratada de forma consistente dentro de um processo de engenharia de domínio. Para demonstrar esta tese, é apresentada uma abordagem orientada a modelos para reutilização de software, com atividades que guiam o desenvolvedor durante a análise, projeto e implementação do domínio. São também apresentados os resultados de uma avaliação envolvendo três estudos empíricos, realizados em ambiente acadêmico e industrial, que buscou determinar a viabilidade da abordagem e os benefícios que podem ser alcançados com a combinação de técnicas do desenvolvimento orientado a modelos e da reutilização de software. Os resultados mostram que a abordagem pode trazer diferentes benefícios para organizações de software, incluindo aumento da quantidade e qualidade da reutilização, e reduzindo a complexidade de desenvolvimento e configuração de produtos / Software reuse aims at increasing quality and productivity in software development, avoiding effort duplication and reusing all past experiences possible. Although it is a simple idea, it is not easy to put reuse in practice, especially in a systematic and controlled way. Domain engineering and software product lines techniques try to make this task easier, but there are many other factors that difficult the reuse adoption. Among these factors are the problems that are inherent to software development in the way it is conducted today, based on source code. These problems arise from the growing demand for increasingly complex software, negatively affecting the ability to reuse. Model-driven development is an attractive alternative in this scenario, leveraging the importance of models in the software life cycle, incorporating them as part of the final product through modeling and code generation techniques. As a result, part of the software complexity becomes hidden inside the generators, shielding the developers, reducing errors, increasing the productivity, quality, interoperability and maintainability of the produced assets. In this dissertation is presented the thesis that model-driven development can effectively increase and/or improve software reuse, and that to achieve this goal it must be treated in a consistent way inside a domain engineering process. To demonstrate this thesis, a model-driven software reuse approach is presented, with activities that guide the developer during domain analysis, design and implementation. The results of an evaluation involving three empirical studies are also presented. The studies were performed in both academic and industrial environments, and aimed at determining the viability of the approach and the benefits that can be achieved with the combination of model-driven development and software reuse techniques. The results showed that the approach can bring different benefits to software organizations, such as software reuse quantity and quality improvements, and complexity reduction in product development and configuration tasks Desenvolvimento orientado a modelos Engenharia de Domínio Linguagens específicas de domínio Linhas de produtos de software Programação generativa Reutilzação de szoftware Domain engineering Domain-Specific languages Generative programming Model-driven development Software product lines Software reuse
22	A Domain Specific Embedded Language in C++ for lowest-order methods for diffusive problem on general meshes Gratien, Jean-Marc 27 May 2013 (has links) (PDF) La spécificité des logiciels scientifiques développés par IFP Energies nouvelles tient avant tout à l'originalité des modèles représentant les situations physiques exprimés sous forme de systèmes d'EDPs assortis de lois de fermeture complexes. Le développement de ces logiciels, conçus pour être exécutés sur les super calculateurs parallèles modernes, nécessite de combiner des méthodes volumes finis robustes et efficaces avec des technologies informatiques qui permettent de tirer au mieux parti de ces calculateurs (parallélisme, gestion de la mémoire, réseaux d'interconnexion, etc). Ces technologies de plus en plus sophistiquées ne peuvent plus être maîtrisées dans leur ensemble par les chercheurs métiers chargés d'implémenter des nouveaux modèles. Dans ce rapport nous proposons un langage spécifique aux méthodes de discrétisation Volumes Finis permettant le prototypage rapide de codes industriels ou de recherche. Nous décrivons le cadre mathématique sur lequel nous nous basons ainsi que la mise au point du nouveau langage. Les travaux out été validés sur des problèmes académiques puis par le prototypage d'une application industrielle dans le cadre de l'axe ''CO2 maîtrisé''. DSEL HPC GP-GPU EDP VF Generative programming méthode de bas ordre
23	Well-Formed and Scalable Invasive Software Composition / Wohlgeformte und Skalierbare Invasive Softwarekomposition Karol, Sven 26 June 2015 (has links) (PDF) Software components provide essential means to structure and organize software effectively. However, frequently, required component abstractions are not available in a programming language or system, or are not adequately combinable with each other. Invasive software composition (ISC) is a general approach to software composition that unifies component-like abstractions such as templates, aspects and macros. ISC is based on fragment composition, and composes programs and other software artifacts at the level of syntax trees. Therefore, a unifying fragment component model is related to the context-free grammar of a language to identify extension and variation points in syntax trees as well as valid component types. By doing so, fragment components can be composed by transformations at respective extension and variation points so that always valid composition results regarding the underlying context-free grammar are yielded. However, given a language’s context-free grammar, the composition result may still be incorrect. Context-sensitive constraints such as type constraints may be violated so that the program cannot be compiled and/or interpreted correctly. While a compiler can detect such errors after composition, it is difficult to relate them back to the original transformation step in the composition system, especially in the case of complex compositions with several hundreds of such steps. To tackle this problem, this thesis proposes well-formed ISC—an extension to ISC that uses reference attribute grammars (RAGs) to specify fragment component models and fragment contracts to guard compositions with context-sensitive constraints. Additionally, well-formed ISC provides composition strategies as a means to configure composition algorithms and handle interferences between composition steps. Developing ISC systems for complex languages such as programming languages is a complex undertaking. Composition-system developers need to supply or develop adequate language and parser specifications that can be processed by an ISC composition engine. Moreover, the specifications may need to be extended with rules for the intended composition abstractions. Current approaches to ISC require complete grammars to be able to compose fragments in the respective languages. Hence, the specifications need to be developed exhaustively before any component model can be supplied. To tackle this problem, this thesis introduces scalable ISC—a variant of ISC that uses island component models as a means to define component models for partially specified languages while still the whole language is supported. Additionally, a scalable workflow for agile composition-system development is proposed which supports a development of ISC systems in small increments using modular extensions. All theoretical concepts introduced in this thesis are implemented in the Skeletons and Application Templates framework SkAT. It supports “classic”, well-formed and scalable ISC by leveraging RAGs as its main specification and implementation language. Moreover, several composition systems based on SkAT are discussed, e.g., a well-formed composition system for Java and a C preprocessor-like macro language. In turn, those composition systems are used as composers in several example applications such as a library of parallel algorithmic skeletons. Software Komposition invasiv templates Meta-Programmierung Schnittstellen Code-Generierung generative Softwareentwicklung Java Syntaxbaum Parser Attributgrammariken Referenzattributgrammatiken CPP C-Preprocessor Aspektorientierte Programmierung Wohlgeformtheit abstrakter Syntaxgraph macros Expansion Kompilierer Programme statische Semantik BPMN Programmiersprachen domänenspezifische Sprachen Sprachkomposition C C++ invasive software composition component aspects weaving correct weaving well-formedness attribute grammars island grammars SkAT skeletons generative programming metaprogramming metamodeling Reuseware C C++ Java JastAdd JastAddJ Compilers RAG preprocessor macros decomposition code syntax tree graphs templates grammars context-sensitive context-free COMPOST EMFText JastEMF parsing expression grammars domain-specific languages BPMN embedded languages language composition ddc:004 rvk:ST 233
24	Well-Formed and Scalable Invasive Software Composition Karol, Sven 18 May 2015 (has links) Software components provide essential means to structure and organize software effectively. However, frequently, required component abstractions are not available in a programming language or system, or are not adequately combinable with each other. Invasive software composition (ISC) is a general approach to software composition that unifies component-like abstractions such as templates, aspects and macros. ISC is based on fragment composition, and composes programs and other software artifacts at the level of syntax trees. Therefore, a unifying fragment component model is related to the context-free grammar of a language to identify extension and variation points in syntax trees as well as valid component types. By doing so, fragment components can be composed by transformations at respective extension and variation points so that always valid composition results regarding the underlying context-free grammar are yielded. However, given a language’s context-free grammar, the composition result may still be incorrect. Context-sensitive constraints such as type constraints may be violated so that the program cannot be compiled and/or interpreted correctly. While a compiler can detect such errors after composition, it is difficult to relate them back to the original transformation step in the composition system, especially in the case of complex compositions with several hundreds of such steps. To tackle this problem, this thesis proposes well-formed ISC—an extension to ISC that uses reference attribute grammars (RAGs) to specify fragment component models and fragment contracts to guard compositions with context-sensitive constraints. Additionally, well-formed ISC provides composition strategies as a means to configure composition algorithms and handle interferences between composition steps. Developing ISC systems for complex languages such as programming languages is a complex undertaking. Composition-system developers need to supply or develop adequate language and parser specifications that can be processed by an ISC composition engine. Moreover, the specifications may need to be extended with rules for the intended composition abstractions. Current approaches to ISC require complete grammars to be able to compose fragments in the respective languages. Hence, the specifications need to be developed exhaustively before any component model can be supplied. To tackle this problem, this thesis introduces scalable ISC—a variant of ISC that uses island component models as a means to define component models for partially specified languages while still the whole language is supported. Additionally, a scalable workflow for agile composition-system development is proposed which supports a development of ISC systems in small increments using modular extensions. All theoretical concepts introduced in this thesis are implemented in the Skeletons and Application Templates framework SkAT. It supports “classic”, well-formed and scalable ISC by leveraging RAGs as its main specification and implementation language. Moreover, several composition systems based on SkAT are discussed, e.g., a well-formed composition system for Java and a C preprocessor-like macro language. In turn, those composition systems are used as composers in several example applications such as a library of parallel algorithmic skeletons. info:eu-repo/classification/ddc/004 ddc:004
25	Generic Programming and Algebraic Multigrid for Stabilized Finite Element Methods / Generisches Programmieren und Algebraische Mehrgitterverfahren für Stabilisierte Finite Elemente Methoden Klimanis, Nils 10 March 2006 (has links) No description available. 510 Mathematik Mathematics and Computer Science Algebraische Mehrgitterverfahren Navier-Stokes Oseen Generisches Programmieren Generatives Programmieren C++ Mixins Templates Finite Elemente Algebraic Multigrid Navier-Stokes Oseen Generic Programming Generative Programming C++ Mixins Templates Finite Elements 31.76 54.51 EGFM 600: Finite elements Rayleigh-Ritz and Galerkin methods boundary value problems}

Page generated in 0.1578 seconds