The major problem addressed in this thesis is the definition of a new SPLE methodology that covers both phases of the SPLE process and focuses on the derivation of behavioral models of SPL products. In Chapter 2 three research areas scope context of this thesis: Software Product Lines, Business Processes, and Model-Driven Engineering. Throughout Chapter 3, we propose a new SPLE methodology that focuses on the derivation of product behavior. We first describe the main flow of the methodology, and then detail the individual steps. In chapter 4 we propose a new domain specific language called CBPF created for modeling composable business process fragments. A model driven approach is followed for creating CBPF: definition of the abstract syntax, graphical concrete syntax and translational semantics. In Chapter 5 we propose several types of verifications that can be applied to business processfragments to determine their "correctness". For structural verification we definine a set of fragment consistency rules that should be valid for every business process fragment created with CBPF. To check behavioral correctness we first transform the business process fragment into an equivalent HCPN. We can then check generic properties but also define aset of fragment specific properties. In chapter 6 we exemplify the proposed SPL methodology by applying it to a case study from the crisis management system domain. We also propose a tool suite that supports our methodology. Chapter 7 describes possible improvements and extensions to the contributions of this thesis. We conclude the thesis in Chapter 8 and draw some conclusions.

Geometric Multigrid (GMG) methods are widely used in numerical analysis to accelerate the convergence of partial differential equations solvers using a hierarchy of grid discretizations. These solvers find plenty of applications in various fields in engineering and scientific domains, where solving PDEs is of fundamental importance. Using multigrid methods, the pace at which the solvers arrive at the solution can be improved at an algorithmic level. With the advance in modern computer architecture, solving problems with higher complexity and sizes is feasible - this is also the case with multigrid methods. However, since hardware support alone cannot achieve high performance in execution time, there is a need for good software that help programmers in doing so. Multiple grid sizes and recursive expression of multigrid cycles make the task of manual program optimization tedious and error-prone. A high-level language that aids domain experts to quickly express complex algorithms in a compact way using dedicated constructs for multigrid methods and with good optimization support is thus valuable. Typical computation patterns in a GMG algorithm includes stencils, point-wise accesses, restriction and interpolation of a grid. These computations can be optimized for performance on modern architectures using standard parallelization and locality enhancement techniques. Several past works have addressed the problem of automatic optimizations of computations in various scientific domains using a domain-specific language (DSL) approach. A DSL is a language with features to express domain-specific computations and compiler support to enable optimizations specific to these computations. Halide and PolyMage are two of the recent works in this direction, that aim to optimize image processing pipelines. Many computations like upsampling and downsampling an image are similar to interpolation and restriction in geometric multigrid methods. In this thesis, we demonstrate how high performance can be achieved on GMG algorithms written in the PolyMage domain-specific language with new optimizations we added to the compiler. We also discuss the implementation of non-trivial optimizations, on PolyMage compiler, necessary to achieve high parallel performance for multigrid methods on modern architectures. We realize these goals by: • introducing multigrid domain-specific constructs to minimize the verbosity of the algorithm specification; • storage remapping to reduce the memory footprint of the program and improve cache locality exploitation; • mitigating execution time spent in data handling operations like memory allocation and freeing, using a pool of memory, across multiple multigrid cycles; and • incorporating other well-known techniques to leverage performance, like exploiting multi-dimensional parallelism and minimizing the lifetime of storage buffers. We evaluate our optimizations on a modern multicore system using five different benchmarks varying in multigrid cycle structure, complexity and size, for two-and three-dimensional data grids. Experimental results show that our optimizations: • improve performance of existing PolyMage optimizer by 1.31x; • are better than straight-forward parallel and vector implementations by 3.2x; • are better than hand-optimized versions in conjunction with optimizations by Pluto, a state-of-the-art polyhedral source-to-source optimizer, by 1.23x; and • achieve up to 1.5$\times$ speedup over NAS MG benchmark from the NAS Parallel Benchmarks. (The speedup numbers are Geometric means over all benchmarks)

Graphs model relationships across real-world entities in web graphs, social network graphs, and road network graphs. Graph algorithms analyze and transform a graph to discover graph properties or to apply a computation. For instance, a pagerank algorithm computes a rank for each page in a webgraph, and a community detection algorithm discovers likely communities in a social network, while a shortest path algorithm computes the quickest way to reach a place from another, in a road network. In Domains such as social information systems, the number of edges can be in billions or trillions. Such large graphs are processed on distributed computer systems or clusters. Graph algorithms can be executed on multi-core CPUs, GPUs with thousands of cores, multi-GPU devices, and CPU+GPU clusters, depending on the size of the graph object. While programming such algorithms on heterogeneous targets, a programmer is required to deal with parallelism and and also manage explicit data communication between distributed devices. This implies that a programmer is required to learn CUDA, OpenMP, MPI, etc., and also the details of the hardware architecture. Such codes are error prone and di cult to debug. A Domain Speci c Language (DSL) which hides all the hardware details and lets the programmer concentrate only the algorithmic logic will be very useful. With this as the research goal, Falcon, graph DSL and its compiler have been developed. Falcon programs are explicitly parallel and Falcon hides all the hardware details from the programmer. Large graphs that do not t into the memory of a single device are automatically partitioned by the Falcon compiler. Another feature of Falcon is that it supports mutation of graph objects and thus enables programming dynamic graph algorithms. The Falcon compiler converts a single DSL code to heterogeneous targets such as multi-core CPUs, GPUs, multi-GPU devices, and CPU+GPU clusters. Compiled codes of Falcon match or outperform state-of-the-art graph frameworks for di erent target platforms and benchmarks.

Les systèmes temps réel (STR) sont au coeur de machines souvent jugés critiques pour lasécurité : ils en contrôlent l’exécution afin que celles-ci se comportent de manière sûre dans le contexte d’un environnement dont l’évolution peut être imprévisible. Un STR n’a d’autre alternative que de s’adapter à son environnement : sa correction dépend des temps de réponses aux stimuli de ce dernier.Il est couramment admis que le formalisme des réseaux de Petri temporels (RdPT) est adapté àla description des STR. Cependant, la modélisation de systèmes simples, ne possédant que quelquestˆaches périodiques ordonnancées de façon basique se révèle être un exercice souvent complexe.En premier lieu, la modélisation efficace d’une gamme étendue de politiques d’ordonnancementsse heurte à l’incapacité des RdPT à imposer un ordre d’apparition à des évènements concurrentssurvenant au même instant. D’autre part, les STR ont une nette tendance à être constitués de caractéristiques récurrentes, autorisant une modélisation par composants. Or les RdPT ne sont guèreadaptés à une utilisation compositionnelle un tant soit peu générale. Afin de résoudre ces deuxproblèmes, nous proposons dans cette thèse Cifre – en partenariat entre Airbus et le Laas-Cnrs– d’étendre les RdPT à l’aide de deux nouvelles relations, les relations d’inhibition et de permission,permettant de spécifier de manière plus fine les contraintes de temps.Afin de cerner un périmètre clair d’adéquation de cette nouvelle extension à la modélisation dessystèmes temps réel, nous avons défini Pola, un langage spécifique poursuivant deux objectifs :déterminer un sous-ensemble des systèmes temps réel modélisables par les réseaux de Petri temporelsà inhibitions/permissions et fournir un langage simple à la communauté temps réel dont lavérification, idéalement automatique, est assurée par construction. Sa sémantique est donnée par traduction en réseaux de Petri temporels à inhibitions/permissions. L’explorateur d’espace d’états de laboite à outils Tina a été étendu afin de permettre la vérification des descriptions Pola / Real time systems (RTS) are at the core of safety critical devices : they control thedevices’ behavior in such a way that they remain safe with regard to an unpredictable environment. ARTS has no other choices than to adapt to its environment : its correctness depends upon its responsetime to the stimuli stemming from the environment.It is widely accepted that the Time Petri nets (TPN) formalism is adapted to the description ofRTS. However, the modeling of simple systems with only a few periodic tasks scheduled according toa basic policy remains a challenge in the worst case and can be very tedious in the most favorable one.First, we put forward some limitations of TPN regarding the modeling of a wide variety of schedulingpolicies, coming from the fact that this formalism is not always capable to impose a givenorder on events whenever they happen at the same time. Moreover, RTS are usually constituted of thesame recurring features, implying a compositional modeling, but TPN are not well adapted to sucha compositional use. To solve those problems we propose in this Cifre thesis – in partnership withAirbus and the Laas-Cnrs – to extend the formalism with two new dual relations, the forbid andallow relations so that time constraints can be finely tuned.Then, to assess this new extension for modeling of real time systems, we define Pola, a specificlanguage aimed at two goals : to determine a subset of RTS which can be modeled with forbid/allowtime Petri nets and to provide a simple language to the real time community which, ideally, can bechecked automatically. Its semantics is given by translation into forbid/allow Time Petri nets. Thestate space exploration tool of the Tina toolbox have been extended so that it can model check Poladescriptions.

Ensuring code quality is crucial in software development. Not seldom, developers resort to static analysis tools to assist them in both understanding pieces of code and identifying defects or refactoring opportunities during development activities. A critical issue when defining such tools is their ability to obtain information about code. Static analysis tools depend, in general, of an intermediate program representation to identify locations that meet the conditions described in their algorithms. This perspective can be enlarged when techniques of crosscutting concerns modularization, such as aspect-oriented programming (AOP) is applied. In AOP applications, a piece of code can be systematically affected, using both static and dynamic combinations. The main goal of this dissertation is the specification and the implementation of AQL, a domain-specific language (DSL) designed to search aspect-oriented code bases. AQL is a declarative language, based on object query language (OQL), which enables the task of querying elements, relationships and program metrics to support the construction of static analysis and code searching tools for aspect oriented programs. The language was designed in two steps. First, we built a framework (AOPJungle), responsible to extract data from aspect-oriented programs. AOPJungle performs the computation of metrics, inferences and connections between the elements of the program. In the second step, we built an AQL compiler as a reference implementation. We adopted a source-to-source transformation for this step, in which an AQL query is transformed into HQL statements before being executed. In order to evaluate the reference implementation, we developed a static analysis tool for identifying refactoring opportunities in aspect-oriented programs. This tool receives a set of AQL queries to identify potential scenarios where refactoring could be applied. / Assegurar a qualidade de código é um ponto crucial durante o desenvolvimento de software. Frequentemente, os desenvolvedores recorrem às ferramentas de análise estática para auxiliá-los tanto na compreensão de código, quanto na identificação de defeitos ou de oportunidades de refatoração durante o ciclo de desenvolvimento de aplicações. Um dos pontos críticos na definição de tais ferramentas está na sua capacidade de obter informações a respeito de código. As ferramentas de análise estática dependem, em geral, de uma representação intermediária de um programa para identificar situações que atendam às condições necessárias descritas em seus algoritmos. Esse panorama se amplia com o uso de técnicas de modularização de interesses transversais, tais como a programação orientada a aspectos (POA), na qual um código pode ser afetado de forma sistêmica, por meio de combinações estáticas e dinâmicas. O principal objetivo desta dissertação é a especificação e implementação de AQL, uma DSL (linguagem específica de domínio) para a realização de busca em código orientado a aspectos. A AQL é uma linguagem declarativa, baseada em linguagem de busca em objetos (OQL) e que permite consultar elementos, relações, derivações e métricas de um programa orientado a aspectos (OA), a fim de apoiar a construção de ferramentas de análise estática e de pesquisa em código. O projeto de implementação da linguagem foi realizado em duas etapas. Primeiro, foi criado um framework (AOPJungle) para a extração de dados de programas OA. O AOPJungle além de extrair dados de programas OA, realiza a computação de métricas, inferências e ligações entre os elementos de um programa. Na segunda etapa, um compilador de referência para AQL foi construído. A abordagem adotada foi a transformação fonte a fonte, sendo uma consulta AQL transformada em uma consulta HQL (Hibernate Query Language) antes de sua execução. A fim de avaliar a implementação proposta, uma ferramenta de análise estática para identificação de oportunidades de refatoração em programas AO foi elaborada, usando a AQL para a busca de dados sobre esses programas.

De nos jours, les processus métiers permettent une automatisation croissante des tâches et des interconnexions complexes au sein du même système et entre différents systèmes, ce qui est particulièrement facilité par l'émergence des services Web. Dans ce contexte, les tâches de spécification et de vérification de la conformité pendant l’exécution deviennent particulièrement intéressantes. Dans cette thèse, on s’intéresse à deux aspects, le monitoring et la sécurité dans le contexte de l’Architecture Orienté Service (SOA). Ainsi, nous proposons une approche fondée sur le concept de vue et une plateforme qui vise le monitoring de la conformité des processus métiers pendant leur exécution. Ainsi, nous avons développé un langage de monitoring appelé BPath, qui est un langage basé sur XPath, qui offre entre autres, la possibilité de spécifier et de vérifier des propriétés de la logique temporelle linéaire et hybride, des requêtes visant à évaluer des indicateurs quantitatifs sur l’exécution d’un processus métier, ceci dans le but de détecter toute violation des règles de conformité pendant l’exécution.Une des préoccupations spécifiques du monitoring de la conformité pour les environnements basés sur SOA est la sécurité. Ainsi, nous proposons une architecture de sécurité fondée sur des langages dédiés (DSL) pour SOA. Nous avons particulièrement développé une DSL graphique pour faciliter la spécification et la génération des contrôles d’accès. Nos approches sont mises en œuvre et intégrés dans une plateforme développée dans le cadre du projet Européen COMPAS qui vise à assurer la conformité de bout en bout dans les environnements basés sur SOA. / Nowadays, business processes allow more automation of tasks and complex interconnections within the same system and across different systems, which is particularly facilitated by the emergence of Web services. In this context, the tasks of specifying and checking compliance at runtime become particularly challenging.In this thesis, our goal is twofold: monitoring and security in the context of Service Oriented Architecture (SOA). Thus, we proposed a view-based monitoring approach and a framework that target monitoring of business process compliance at runtime. Our monitoring framework aims to offer an easy way to specify properties to be monitored and to facilitate its integration with SOA based environments. Thus, we have developed a new monitoring language called BPath, which is an XPath-based language that offers among others, the ability to express and to check temporal and hybrid logic properties at runtime, making the execution of business processes visible by expressing and evaluating quantitative indicators, in order to detect any compliance violation at runtime. A specific compliance monitoring concern in SOA based environment is security, which is also an important aspect for companies willing to give access to some of their resources over the Web. Thus, we proposed a domain specific language (DSL) based architecture for ensuring security in SOA environments. We particularly focused on access control by proposing a graphical language to facilitate the specification and generation of access control policies.Our approaches are implemented and integrated within a complete end to end compliance framework developed within the COMPAS project.

Cloud computing has become an established paradigm for running services on external infrastructure that dynamically allocates virtually unlimited capacity. This paradigm creates a new scenario for the deployment of applications and information technology (IT) services. In this model, complete applications and machine infrastructure are offered to users, who are charged only for the resources they consume. Thus, cloud resources are offered through service abstractions classified into three main categories: Software as a Service (SaaS), Platform as a Service (PaaS), and Infrastructure as a Service (IaaS). In IaaS, computing resources are offered as virtual machines to the end user. The aim to offer such unlimited resources necessitates distributing these virtual machines through multiple data centers. This distribution makes harder to fulfill a number of requirements including security, reliability, availability, and accounting. Accounting refers to how resources are recorded, accounted for, and charged. Even for a single cloud provider this task is hard, and it becomes more difficult for a federation of cloud computing, or federated cloud, in which a cloud provider dynamically outsources resources to other providers in response to demand variation. Thus, a cluster of clouds shares heterogeneous resources, requiring greater effort to manage and accurately account for the distributed resources. Some earlier research has addressed the development of platforms for federated clouds but without considering the accounting requirement. This dissertation presents a framework for charging IaaS with a focus on federated cloud. In order to gather information about this topic area and to generate guidelines for building the framework, we applied a systematic mapping study. This dissertation also presents an initial validation of the tool through a case study, showing evidence that the requirements generated through the mapping study were fulfilled by the framework and presenting indications of its feasibility in a real cloud service scenario / Submitted by João Arthur Martins (joao.arthur@ufpe.br) on 2015-03-10T18:37:17Z No. of bitstreams: 2 Dissertação Francisco Airton da Silva.pdf: 5605679 bytes, checksum: 61aa2b6df102174ff2e190ab47678cbf (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) / Made available in DSpace on 2015-03-11T17:45:06Z (GMT). No. of bitstreams: 2 Dissertação Francisco Airton da Silva.pdf: 5605679 bytes, checksum: 61aa2b6df102174ff2e190ab47678cbf (MD5) license_rdf: 1232 bytes, checksum: 66e71c371cc565284e70f40736c94386 (MD5) Previous issue date: 2013-02-27 / A Computação na Nuvem se tornou um paradigma consumado para executar serviços em infraestruturas externas, onde de uma forma virtual a capacidade praticamente ilimitada pode ser alocada dinamicamente. Este paradigma estabelece um novo cenário para a implantação de aplicações e serviços de TI. Neste modelo, desde aplicações completas até infraestrutura de máquinas são ofertadas a usuários, que são cobrados apenas pelo uso dos recursos consumidos. Desta forma, os bens de consumo da nuvem são ofertados através de abstrações de serviços, onde atualmente são citadas três principais categorias: Software como Serviço (SaaS), Plataforma como Serviço (PaaS) e Infraestrutura como Serviço (IaaS). No caso do IaaS são oferecidos recursos computacionais na forma de Máquinas Virtuais para o cliente final. Para atingir o aspecto ilimitado de recursos é necessário distribuir estas Máquinas Virtuais por vários Data Centers. Esta distribuição dificulta atender uma série de requisitos como Segurança, Confiabilidade, Disponibilidade e a Tarifação pelos recursos consumidos. A Tarifação refere-se a como os recursos são registrados, contabilizados e cobrados. Mesmo no caso de um único provedor esta tarefa não é fácil e existe um contexto em que esta dificuldade se torna ainda maior, conhecida como Federação de Computação na Nuvem ou também chamadas de Nuvens Federadas. Nuvens Federadas ocorrem quando um provedor de Computação na Nuvem terceiriza recursos dinamicamente para outros provedores em resposta à variação da demanda. Desta forma ocorre um aglomerado de nuvens, porém seus recursos são heterogêneos, acarretando num maior esforço para gerenciar os recursos distribuídos e por consequência para a Tarifação. Neste contexto foram identificadas pesquisas nesta área sobre plataformas para Nuvens Federadas, que não abordam o requisito de Tarifação. Esta dissertação apresenta um framework voltado à tarifação de Infraestrutura como Serviço com foco em Nuvens Federadas. Objetivando colher informações sobre esta área e consequentemente gerar insumos para fundamentar as decisões na construção do framework, foi aplicado um Estudo de Mapeamento Sistemático. Esta dissertação também apresenta uma validação inicial da ferramenta, através de um estudo experimental, mostrando indícios de que os requisitos gerados pelo Mapeamento Sistemático foram atendidos, bem como será viável a aplicação da solução por provedores de serviços de nuvem em um cenário real.

Error messages in compilers is a topic that is often overlooked. The quality of the messages can have a big impact on development time and ease oflearning. Another method used to speed up development is to build a domainspecific language (DSL). This thesis migrates an existing framework to use TypeScript in order to speed up development time with compile-time error handling. Alternative methods for implementing a DSL are evaluated based onhow they affect the ability to generate good error messages. This is done usinga proposed list of six usability heuristics for error messages. They are also usedto perform heuristic evaluation on the error messages in the TypeScript compiler. This showed that it struggled with syntax errors but had semantic errormessages with low amount of usability problems. Finally, a method for implementing a DSL and presenting its error messages is suggested. The evaluationof said method showed promise despite the existence of usability problems. / Felmeddelanden i kompilatorer är ett ämne som ofta förbises. Kvaliténpå felmeddelanden kan ha stor påverkan på utvecklingstid och lätthetatt lära. En annan metod för att sänka utvecklingstid är att bygga ettdomänspecifikt programmeringspråk. Detta examensarbete migrerar ettexisterande ramverk till TypeScript för att snabba på utvecklingstidmed felhantering i kompileringsstadiet. Alternativa metoder för attimplementera ett DSL evalueras baserat på hur de påverkar möjlighetenatt generera bra felmeddelanden. Detta görs med en föreslagen lista avsex heuristiker för felmeddelanden. De används också för att utföra enheuristik utvärdering på felmeddelandena i TypeScriptkompilatorn. Detta visade att den har svårt för syntaxfel men hademeddelanden för semantiska fel med låg mängdanvändbarhetsproblem. Till sist föreslås en metod för att implementeraett DSL och presentera dess felmeddelanden. Evalueringen av den nämndametoden visade lovande resultat trots förekomsten av användbarhetsproblem.

L’informatique en nuage, au travers de son modèle en couche et de l’accès à ses services à la demande, a bouleversé la façon de gérer les infrastructures (IaaS) et la manière de produire les logiciels (SaaS). Grâce à l’élasticité de l’infrastructure, la quantité de ressource peut être ajustée automatiquement en fonction de la demande afin de satisfaire un certain niveau de qualité de service (QoS) aux clients tout en minimisant les coûts d’exploitation sous-jacents. Le modèle d’élasticité actuel qui consiste à ajuster les ressources IaaS au travers de services de dimensionnement automatique basiques montre ses limites en termes de réactivité et de granularité d’adaptation. De plus, bien qu’étant une caractéristique cruciale de l’informatique en nuage, l’élasticité est à ce jour pauvrement outillée empêchant ainsi les différents acteurs du Cloud de jouir pleinement de ses bienfaits. Dans ce travail de thèse, nous proposons d’étendre leconcept d’élasticité aux couches hautes du nuage, et plus précisément au niveau du SaaS. Nous présentons ainsi le nouveau concept d’élasticité logicielle que nous définissons comme la capacité d’un logiciel à s’adapter, idéalement de manière autonome, pour répondre aux changements de la demande et/ou aux limitations de l’élasticité des ressources de l’infrastructure. Il s’agit alors d’envisager l’élasticité de manière transverse et multi-couche en considérant l’adaptation des ressources Cloud au sens large. Pour ce faire, nous présentons un modèle pour la gestion autonome de l’élasticité multi-couche et le Framework ElaStuff associé. Dans le but d’outiller et d’industrialiser le processus de gestion de l’élasticité, nous proposons l’outil de surveillance perCEPtion basé sur le traitement des événements complexes et permettant à l’administrateur de mettre en place une observation avancée du système Cloud. De plus, un langage dédié à l’élasticité multi-couche nommé ElaScript est proposé pour exprimer simplement et efficacement des plans de reconfiguration orchestrant les actions d’élasticité de différents niveaux. Enfin, notre proposition d’étendre l’élasticité aux couches hautes du Cloud, et plus particulièrement au niveau SaaS, est validée expérimentalement selon plusieurs points devue (QoS, énergie, réactivité et précision du passage à l’échelle,etc.). / Cloud computing, through its layered model and access to its on-demand services, has changed the way of managing the infrastructures (IaaS) and how to produce software (SaaS). With the advent of IaaS elasticity, the amount of resources can be automatically adjusted according to the demand to satisfy a certain level of quality of service (QoS) to customers while minimizing underlying operating costs. The current elasticity model is based on adjusting the IaaS resources through basic autoscaling services, which reaches to its limit in terms of responsiveness and adaptation granularity. Although it is an essential feature for Cloud computing, elasticity remains poorly equipped which prevents the various actors of the Cloud to really enjoy its benefits. In this thesis, we propose to extend the concept of elasticity to higher layers of the cloud, and more precisely to the SaaS level. Then, we present the new concept of software elasticity by defining the ability of the software to adapt, ideally in an autonomous way, to cope with workload changes and/or limitations of IaaS elasticity. This predicament brings the consideration of Cloud elasticity in a multi-layer way through the adaptation of all kind of Cloud resources. To this end, we present a model for the autonomic management of multi-layer elasticity and the associated framework ElaStuff. In order to equip and industrialize the elasticity management process, we propose the perCEPtion monitoring tool, based on complex event processing, which enables the administrators to set up an advanced observation of the Cloud system. In addition, we propose a domain specific language (DSL) for the multi-layer elasticity, called ElaScript, which allows to simply and effectively express reconfiguration plans orchestrating the different levels of elasticity actions. Finally, our proposal to extend the Cloud elasticity to higher layers, particularly to SaaS,is validated experimentally from several perspectives (QoS,energy, responsiveness and accuracy of the scaling, etc.).

Os Sistemas de Apoio à Decisão (SAD) organizam e processam dados e informações para gerar resultados que apoiem a tomada de decisão em um domínio especifico. Eles integram conhecimento de especialistas de domínio em cada um de seus componentes: modelos, dados, operações matemáticas (que processam os dados) e resultado de análises. Nas metodologias de desenvolvimento tradicionais, esse conhecimento deve ser interpretado e usado por desenvolvedores de software para implementar os SADs. Isso porque especialistas de domínio não conseguem formalizar esse conhecimento em um modelo computável que possa ser integrado aos SADs. O processo de modelagem de conhecimento é realizado, na prática, pelos desenvolvedores, parcializando o conhecimento do domínio e dificultando o desenvolvimento ágil dos SADs (já que os especialistas não modificam o código diretamente). Para solucionar esse problema, propõe-se um método e ferramenta web que usa ontologias, na Web Ontology Language (OWL), para representar o conhecimento de especialistas, e uma Domain Specific Language (DSL), para modelar o comportamento dos SADs. Ontologias, em OWL, são uma representação de conhecimento computável, que permite definir SADs em um formato entendível e accessível a humanos e máquinas. Esse método foi usado para criar o Framework Decisioner para a instanciação de SADs. O Decisioner gera automaticamente SADs a partir de uma ontologia e uma descrição naDSL, incluindo a interface do SAD (usando uma biblioteca de Web Components). Um editor online de ontologias, que usa um formato simplificado, permite que especialistas de domínio possam modificar aspectos da ontologia e imediatamente ver as consequência de suasmudanças no SAD.Uma validação desse método foi realizada, por meio da instanciação do SAD SustenAgro no Framework Decisioner. O SAD SustenAgro avalia a sustentabilidade de sistemas produtivos de cana-de-açúcar na região centro-sul do Brasil. Avaliações, conduzidas por especialistas em sustentabilidade da Embrapa Meio ambiente (parceiros neste projeto), mostraram que especialistas são capazes de alterar a ontologia e DSL usadas, sem a ajuda de programadores, e que o sistema produz análises de sustentabilidade corretas. / Decision Support Systems (DSSs) organize and process data and information to generate results to support decision making in a specific domain. They integrate knowledge from domain experts in each of their components: models, data, mathematical operations (that process the data) and analysis results. In traditional development methodologies, this knowledge must be interpreted and used by software developers to implement DSSs. That is because domain experts cannot formalize this knowledge in a computable model that can be integrated into DSSs. The knowledge modeling process is carried out, in practice, by the developers, biasing domain knowledge and hindering the agile development of DSSs (as domain experts cannot modify code directly). To solve this problem, a method and web tool is proposed that uses ontologies, in the Web Ontology Language (OWL), to represent experts knowledge, and a Domain Specific Language (DSL), to model DSS behavior. Ontologies, in OWL, are a computable knowledge representations, which allow the definition of DSSs in a format understandable and accessible to humans and machines. This method was used to create the Decisioner Framework for the instantiation of DSSs. Decisioner automatically generates DSSs from an ontology and a description in its DSL, including the DSS interface (using a Web Components library). An online ontology editor, using a simplified format, allows that domain experts change the ontology and immediately see the consequences of their changes in the in the DSS. A validation of this method was done through the instantiation of the SustenAgro DSS, using the Decisioner Framework. The SustenAgro DSS evaluates the sustainability of sugarcane production systems in the center-south region of Brazil. Evaluations, done by by sustainability experts from Embrapa Environment (partners in this project), showed that domain experts are capable of changing the ontology and DSL program used, without the help of software developers, and that the system produced correct sustainability analysis.