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.

Nous proposons Dido, un langage dédié (DSL) implicitement parallèle qui capture les spécifications de haut niveau des stencils et génère automatiquement du code parallèle de haute performance pour les architectures à mémoire distribuée. Le code généré utilise ORWL en tant que interface de communication et runtime. Nous montrons que Dido réalise un grand progrès en termes de productivité sans sacrifier les performances. Dido prend en charge une large gamme de calculs stencils ainsi que des applications réelles à base de stencils. Nous montrons que le code généré par Dido est bien structuré et se prête à de différentes optimisations possibles. Nous combinons également la technique de génération de code de Dido avec Pluto l'optimiseur polyédrique de boucles pour améliorer la localité des données. Nous présentons des expériences qui prouvent l'efficacité et la scalabilité du code généré qui atteint de meilleures performances que les implémentations ORWL et MPI écrites à la main. / In this work, we present Dido, an implicitly parallel domain-specific language (DSL) that captures high-level stencil abstractions and automatically generates high-performance parallel stencil code for distributed-memory architectures. The generated code uses ORWL as a communication and synchronization backend. We show that Dido achieves a huge progress in terms of programmer productivity without sacrificing the performance. Dido supports a wide range of stencil computations and real-world stencil-based applications. We show that the well-structured code generated by Dido lends itself to different possible optimizations and study the performance of two of them. We also combine Dido's code generation technique with the polyhedral loop optimizer Pluto to increase data locality and improve intra-node data reuse. We present experiments that prove the efficiency and scalability of the generated code that outperforms both ORWL and MPI hand-crafted implementations.

Resources Events Agents (REA) ontology is a profound business modeling ontology that was developed to define the architecture of accounting information systems. Nevertheless, REA did not manage to get the same attention as other business modeling ontologies. One reason of such abandon is the absence of a meaningful visual notation for the ontology, which has resulted in an abstruse ontology to non-academic audience. Another reason for this abandon is the fact that REA does not have a standard formal representation. This has resulted in a humble amount of researches which have focused on defining meta-models of the ontology while neglecting the wider purpose of REA-based information systems development. Consequently, the ontology was deviated away from its original purpose, and rather used in business schools. To solve the aforementioned issues, this research presents a Model Driven Development (MDD) technique in the form of a REA-based Domain Specific Visual Language (DSVL) that is implemented within a modeling and code generation editor. This effort was taken in order to answer the question of “How would a REA-DSVL based tool make the REA ontology implementable in the domain of information systems development?” In order to answer the research question, a design science methodology (DSRM) was implemented as the structure of this research. The DSRM was chosen because this research aims to develop three main artifacts. These are; a meta-model of REA, a visual notation of REA, and a REA-DSVL-based modeling and code generation tool. The first phase of the DSRM was to identify the problems which were mentioned earlier, followed by the requirements identification phase which drew the outline of the; meta-model, the visual notation, and the tool. After that, the development phase was conducted in order to develop the aforementioned artifacts. The editor was then demonstrated using a case study of a local company in Stockholm-Sweden. Finally, the resulted artifacts were evaluated based on the collected requirements and the results from the case study. Based on the analyses of the artifacts and the case study, this research was concluded with the result that a REA-based DSVL tool can help in boosting the planning and analysis phases of the software development lifecycle (SDLC). This is achieved by automating some of the conventional software planning and design tasks, which would lead to more accurate systems’ designs; thus, minimizing the time of the planning and design phases. And it can be achieved by abstracting the direct logic of REA through providing functionalities that help users from different backgrounds (academic and professional) to embrace a business modeling editor rather than an ontology; thus, attracting a wider users base for implementing REA.

The technological advancements in the automotive industry as well as in thefield of communication technologies done the last years have transformed thevehicles to complex machines that include not only electrical and mechanicalcomponents but also a great number of electronic components. Furthermore,modern vehicles are now connected to the Wide Area Network (WAN) and inthe near future communications will also be present between the cars (Vehicleto-Vehicle, V2V) and between cars and infrastructure (Vehicle-to-Infrastructure, V2I), something that can be found as Internet of Vehicles (IoV)in the literature. The main motivations towards all the aforementioned changesin modern vehicles are of course the improvement of road safety, the higherconvenience of the passengers, the increase in the efficiency and the higher userfriendliness.On the other hand, having vehicles connected to the Internet opens them up toa new domain of interest, this no other than the domain of cyber security. Thispractically means that while previously we were only considering cyber-attackson computational systems, now we need to start thinking about it also forvehicles. This, as a result, creates a new field of research, namely the vehicularcyber security. However, this field does not only include the possible vehicularcyber-attacks and their corresponding defenses but also the modeling andsimulation of them with the use of vehicular security analysis tools, which isalso recommended by the ENISA report titled “Cyber Security and Resilienceof smart cars: Good practices and recommendations”.Building on this need for vehicular security analysis tools, this work aims tocreate and evaluate a domain-specific, probabilistic modeling and simulationlanguage for cyber-attacks on modern connected vehicles. The language will bedesigned based on the existing threat modeling and risk management toolsecuriCAD® by foreseeti AB and more specifically based on its underlyingmechanisms for describing and probabilistically evaluating the cyber threats ofthe models.The outcome/final product of this work will be the probabilistic modeling andsimulation language for connected vehicles, called vehicleLang, that will beready for future use in the securiCAD® software. / De tekniska framstegen inom fordonsindustrin såväl som inomkommunikationsteknik som gjorts de senaste åren har omvandlat fordon tillkomplexa maskiner som inte bara omfattar elektriska och mekaniskakomponenter utan också ett stort antal elektroniska komponenter. Dessutom ärmoderna fordon nu anslutna till Internet (WAN) och inom den närmasteframtiden kommer kommunikation också att etableras mellan bilarna (Vehicleto-Vehicle, V2V) och mellan bilar och infrastruktur (Vehicle-to-Infrastructure,V2I). Detta kan också kallas fordonens internet (Internet of Vehicles - IoV) ilitteraturen. De främsta motiven för alla ovannämnda förändringar i modernafordon är förstås förbättringen av trafiksäkerheten, ökad bekvämlighet förpassagerarna, ökad effektivitet och högre användarvänlighet.Å andra sidan, att ha fordon anslutna till Internet öppnar dem för en ny domän,nämligen cybersäkerhet. Då vi tidigare bara övervägde cyberattacker påtraditionella datorsystem, måste vi nu börja tänka på det även för fordon. Dettaområde omfattar emellertid inte bara de möjliga fordonsattackerna och derasmotsvarande försvar utan även modellering och simulering av dem med hjälpav verktyg för analys av fordonssäkerhet, vilket också rekommenderas avENISA-rapporten med titeln ”Cyber Security and Resilience of smart cars: Goodpractices and recommendations”.På grund av detta behov av verktyg för fordonssäkerhetsanalys syftar dettaarbete till att skapa och utvärdera ett domänspecifikt, probabilistisktmodelleringsspråk för simulering av cyberattacker på moderna anslutna fordon.Språket har utformats utifrån det befintliga hotmodellerings- ochriskhanteringsverktyget securiCAD® av foreseeti AB och mer specifikt baseratpå dess underliggande mekanismer för att beskriva och probabilistiskt utvärderamodellernas cyberhot.Resultatet/slutprodukten av detta arbete är ett probabilistisktmodelleringsspråk för uppkopplade fordon, vehicleLang.

Modeling is a fundamental property in today’s development of embedded systems. Models of computation enable us to describe the functionality and characteristics of a system on a higher abstraction level which gives the designer great insight in the behavior of the final implemented system at a very early stage in the design process. The ForSyDe modeling framework is based on the Model-of-computation (MoC) theory. Synchronous data-flow (SDF) is one MoC that uses actors and tokens to describe the communication and behavior of a system. Currently, the ForSyDe input modeling language exists only as a Haskell implementation and a System C implementation. The main problem is that the ForSyDe tool ecosystem is implemented across different languages without proper connections between tools. However, a framework to make such connections exists, namely the ForSyDe IO Java supporting library. In addition, any language running on the JVM can already be connected to ForSyDe IO. Hence, the thesis explores how a modeling workbench can be designed as a domain specific language (DSL) in the JVM language Groovy using the Gradle environment. Since there are many modules in the ForSyDe modeling framework, one for each MoC, this thesis targets one module: SDF. This choice is enough to explore whether it is possible to achieve the same modeling that Haskell provides in a JVM language, without sacrificing the user experience while modeling. The resulting Groovy DSL can describe the Synchronous Data-Flow MoC with the purpose of modeling SDF graphs, often used in image processing applications. By using the produced DSL workbench, a designer can model SDF applications in an efficient way. There were some differences when comparing the Groovy DSL to the Haskell implementation, such as the methods for defining actors and connecting them. However, the core modeling concepts are the same. Combining Groovy and Gradle offered an easy way of designing a DSL using the concept of closures. The created Groovy DSL is the first member of a family of textual DSL’s for describing MoC’s and therefore acts as a foundation for future work within the ForSyDe modeling framework. It can be extended to support more modules and functions or to inspire others to develop new DSL’s. / Modellering av system är en grundsten i dagens utveckling av inbyggda system. Beräkningsmodeller möjliggör att beskriva systems egenskaper och funktioner på en hög abstraktionsnivå vilket underlättar den första tiden vid utvecklingen av ett nytt inbyggt system. ForSyDe är ett modelleringsspråk baserat på beräkbarhetsteori. Det synkrona dataflödet (SDF) är en beräkningsmodell som använder sig av aktörer och tokens för att beskriva ett systems kommunikation och bettend. ForSyDe är implementerat i programmeringsspråket Haskell och System C, men är i fortsatt utveckling och grenar ut till andra språk och miljöer. Det huvudsakliga Problemet med ForSyDe är att ramverket saknar bra kopplingar mellan verktygen som erbjuds. Ett ramverk som möjliggör kopplingen mellan verktygen är stöd biblioteket ForSyDe IO och dessutom kan ett språk som kör i Javas virtuella miljö redan kopplas med ForSyDe IO. Därför undersöker uppsatsen hur ett domänspecifikt språk kan skrivas i Groovy i utvecklingsmiljön gradle för att direkt extrahera en ForSyDe IO modell utan att behöva undersöka varje element i modellen. Det finns många moduler i ForSyDe ramverket, en för varje beräkningsmodell och därför menar uppsatsen att undersöka en modul: SDF. Att undersöka SDF modulen anses tillräckligt för att bestämma sig huruvida det är möjligt att uppnå liknande modellering som Haskell erbjuder fast i java miljön, utan att offra användarvänligheten då ett system modelleras. Resultatet blev en Groovy prototyp som kan beskriva SDF-modulen med syftet att modellera SDF-grafer vars funktion ofta används inom bildbehandling. En SDF-graf beskriver ett systems dataflöde och via det resulterande domänspecifika språket kan en utvecklare på ett tillfredsställande sätt beskriva dataflöden i javamiljön. Det visade sig att det resulterande domän specifika språket i Groovy skiljer sig en aning från Haskell i hur man specificerar aktörer och deras kopplingar, men det fundamentala konceptet är detsamma. Groovy i kombination med Gradle erbjöd ett smidigt sätt att programmera ett domänspecifikt språk med hjälp av closures vilket kan användas för framtida bruk inom utvecklingsområdet. Den skapade prototypen är den första medlemmen i en familj av framtida modelleringsspråk som beskriver beräkningsmodeller. Resultatet av projektet utgör en grund för ett fortsatt arbete med att bygga vidare på prototypen, men även för att kunna lägga till fler beräkningsmoduler som i sin tur bidrar med utbyggningen av ramverket ForSyDe.

Cyber-physical systems are dynamic physical systems that are controlled by computers for their safe and sound operations (e.g., cars, satellites, robots, elevators, and many others). Consequently, the programs running cyber-physical systems have real-time requirements, which require the programs to compute not only correctly but also timely because dynamic physical systems need to move to correct positions within certain duration to ensure safe and sound operations. To satisfy real-time requirements in better ways, many real-time languages have been proposed in the literature. Nevertheless, the general-purpose non-real-time languages C and C++ have remained the de facto languages to program cyber-physical systems, including Mars rovers and F-35 jet fighters. Given this reality, the better ways to satisfy real-time requirements have been the use of model-based tools (e.g., MATLAB/Simulink) that allow cyber-physical systems to be designed by modeling and simulating them and the resulting models to be translated automatically to C programs. Model-based tools, however, leave the resulting C programs for manual integration with other C/C++ programs, such as legacy/third-party device drivers and libraries. Since manual integration could slip in some inconsistencies, which proved fatal in the maiden flight of Ariane-5 rocket, this work shows how the standard features of C++, which support active libraries, can be used to embed a model-based real-time language, called Tice, as a C++ active library that can be used to declaratively express models of real-time systems that are processable by off-the-shelf standard C++ compilers (e.g., GCC and Clang) that automatically not only translate the models into C/C++ programs but also check both the validity of the models and the consistency of the models with other C/C++ programs. Furthermore, being compilable by off-the-shelf standard C++ compilers also sets Tice apart from other real-time languages already proposed in the literature because the other languages require either their own special compilers/interpreters or non-standard C/C++ compilers. Consequently, while Tice itself either uses no C++ features that are unsuitable for cyber-physical systems (e.g., exception) or uses some in judicious manner (e.g., template instantiations to generate programs), Tice prevents no usage that is permitted by standard C++ compilers. Beside that, as C++ active libraries are indeed ordinary C++ libraries, C++ active libraries are seamlessly composable as ordinary C++ libraries, and therefore, as models play an increasingly important role in software engineering, this work shows the potential of C++ as a platform for language-oriented programming where different languages that express different kinds of models and are embedded as C++ active libraries could be composed seamlessly.

No description available.