Model-driven development for pervasive information systems

This chapter focus on design methodologies for pervasive information systems (PIS). It aims to contribute for the efficiency and effectiveness on software development of ubiquitous services/applications supported on pervasive information systems. Pervasive information systems are composed of conveniently orchestrated embedded or mobile computing devices that offer innovative ways to support existing and new business models. Those systems are characterized as having a potential large number of interactive heterogeneous embedded/mobile computing devices that collect, process, and communicate information. Additionally, they are target of high rates of technological innovations. Therefore, changes on requirements or in technology demands for frequent modifications on software at device and system levels. Software design and evolution for those requires suitable approaches that cope with such demands and characteristics of pervasive information systems. Model-driven development approaches (which essentially centre the focus of development on models, and involves concepts such as Platform-Independent Models, Platform-Specific Models, model transformations, and use of established standards) currently in research at academic and industrial arenas to design of large systems, offer potential benefits that can be applied to design and evolution of these pervasive information systems. In this chapter, we raise issues and propose strategies related to the software development of PIS using a model-driven development perspective

Compilation and Binary Editing for Performance and Security

Traditionally, execution of a program follows a straight and inflexible path starting from source code, extending through a compiled executable file on disk, and culminating in an executable image in memory. This dissertation enables more flexible programs through new compilation mechanisms and binary editing techniques. To assist analysis of functions in binaries, a new compilation mechanism generates data representing control flow graphs of each function. These data allow binary analysis tools to identify the boundaries of basic blocks and the types of edges between them without examining individual instructions. A similar compilation mechanism is used to create individually relocatable basic blocks that can be relocated anywhere in memory at runtime to simplify runtime instrumentation. The concept of generating relocatable program components is also applied at function-level granularity. Through link-time function relocation, unused functions in shared libraries are moved to a section that is not loaded into the memory at runtime, reducing the memory footprint of these shared libraries. Moreover, function relocation is extended to the runtime where functions are continuously moved to random addresses to thwart system intrusion attacks. The techniques presented above result in a 74% reduction in binary parsing times as well as an 85% reduction in memory footprint of the code segment of shared libraries, while simplifying instrumentation of binary code. The techniques also provide a way to make return-oriented programming attacks virtually impossible to succeed

Automating System-Level Data-Interchange Software Through a System Interface Description Language

RÉSUMÉ Les plates-formes d'aujourd'hui, telles que les simulateurs de missions (FMS), présentent un niveau sans précédent d'intégration de systèmes matériels et logiciels. Dans ce contexte, les intégrateurs de systèmes sont confrontés à une hétérogénéité d'interfaces système qui doivent être alignées et reliées ensemble afin de fournir les capacités prévues d'une plate-forme. Le seul aspect des échanges de données système est problématique allant de données désalignées jusqu'à des environnements multi-architecturaux utilisant différents types de protocoles de communication. Les intégrateurs sont également confrontés à des défis similaires lors de l'interaction de multiples plates-formes ensemble à travers des environnements de simulation distribuée où chaque plate-forme peut être considérée comme un système avec sa propre interface distincte. D'autre part, permettre la réutilisation de système à travers diverses plates-formes en support aux gammes de produits est un défi pour les fournisseurs de systèmes, car ils doivent adapter leurs interfaces système à des plates-formes hétérogènes faisant donc face aux mêmes difficultés que les intégrateurs. En outre, l'introduction de modifications aux interfaces système afin de répondre aux besoins tardifs d'affaires, ou à des contraintes de performance imprévues, par exemple, est d'autant plus ardue que leurs impacts sont difficiles à prévoir et que leurs effets sont souvent décelés tard dans le processus d'intégration. En conséquence, cette thèse aborde la nécessité de simplifier l'intégration et l'interopérabilité système afin de réduire leurs coûts associés et d'accroître leur efficacité ainsi que leur efficience. Elle est destinée à apporter de nouvelles avancées dans les domaines de l'intégration système et de l'interopérabilité système. Notamment, en établissant une taxonomie commune, et en augmentant la compréhension des interfaces système, des divers aspects impactant les échanges de données système, des considérations des environnements multi-architecturaux, ainsi que des facteurs permettant la gouvernance d'interface ainsi que de la réutilisation système. À cette fin, deux objectifs de recherche ont été formulés. Le premier objectif vise à définir un langage utilisé pour décrire les interfaces système et les divers aspects entourant leurs échanges de données. Par conséquent, trois aspects principaux sont étudiés relatifs aux interfaces système: les éléments de langage pertinents utilisés pour les décrire, la modélisation des interfaces système avec ce langage, et la capture des considérations multi-architecturales. Le second objectif vise à définir une méthode pour automatiser le logiciel responsable des échanges de données système comme moyen pour simplifier les tâches impliquées dans l'intégration et l'interopérabilité système. Par conséquent, les compilateurs de modèles et les techniques de génération de code sont étudiés. La démonstration de ces objectifs apporte de nouvelles avancées dans l'état de l'art de l'intégration système et de l'interopérabilité système. Notamment, ceci culmine en un nouveau langage de description d'interface système, SIDL, utilisé pour capturer les interfaces système et les divers aspects entourant leurs échanges de données, ainsi qu'en une nouvelle méthode pour automatiser le logiciel d'échange de données au niveau système à partir des interfaces systèmes capturées dans ce langage. L'avènement de SIDL contribue également une nouvelle taxonomie fournissant une perspective complète sur l'interopérabilité système ainsi qu'en un langage commun qui peut être partagé entre les parties prenantes, tels que les intégrateurs, les fournisseurs et les experts système. Étant agnostique aux architectures, SIDL fournit un seul point de vue architectural supervisant toutes les interfaces système et capture les considérations multi-architecturales ce qui n'a jamais été réalisé avant ce travail. D'autant plus, un générateur de code SIDL est introduit présentant la nouveauté de générer le logiciel d'échange de données à partir d'un bassin plus riche d'information, notamment à partir des relations système de haut niveau allant jusqu'au bas niveau couvrant les détails protocolaires et d'encodage. En raison des considérations multi-architecturales qui sont capturées nativement dans SIDL, ceci permet au générateur de code d'être agnostique aux architectures le rendant réutilisable dans d'autres contextes. Cette thèse ouvre également la voie à de futures recherches bâtissant sur ses contributions. Elle propose même une vision pour le développement d'applications logicielles avec comme objectif final de repousser encore plus loin les limites de la simplification et de l'automatisation des tâches liées à l'intégration et à l'interopérabilité système.----------ABSTRACT Today’s platforms, such as full mission simulators (FMSs), exhibit an unprecedented level of hardware and software system integration. In this context, system integrators face heterogeneous system interfaces which need to be aligned and interconnected together in order to deliver a platform's intended capabilities. The sole aspect of the data systems exchange is problematic ranging from data misalignment up to multi-architecture environments over varying kinds of communication protocols. Similar challenges are also faced by integrators when interoperating multiple platforms together through distributed simulation environments where each platform can be seen as a system with its own distinct interface. On the other hand, enabling system reuse across multiple platforms for product line support is challenging for system suppliers, as they need to adapt system interfaces to heterogeneous platforms therefore facing similar challenges as integrators. Furthermore, the introduction of system interface changes in order to respond to late business needs, or unforeseen performance constraints for instance, is even more arduous as impacts are challenging to predict and their effect are often found late into the integration process. Consequently, this thesis tackles the need to simplify system integration and interoperability in order to reduce their associated costs and increase their effectiveness along with their efficiency. It is meant to bring new advances in the fields of system integration and system interoperability. Notably, by establishing a common taxonomy, and by increasing the understanding of system interfaces, the various aspects impacting system data exchanges, multi-architecture environment considerations, and the factors enabling interface governance as well as system reuse. To this end, two research objectives have been formulated. The first objective aims at defining a language used to describe system interfaces and the various aspects surrounding their data exchanges. Therefore, three key aspects are studied relating to system interfaces: the relevant language elements used to describe them, modeling system interfaces with the language, and capturing multi-architecture considerations. The second objective aims at defining a method to automate the software responsible for system data exchanges as a way of simplifying the tasks involved in system integration and interoperability. Therefore, model compilers and code generation techniques are studied. The demonstration of these objectives brings new advances in the state of the art of system integration and system interoperability. Notably, this culminates in a novel system interface description language, SIDL, used to capture system interfaces and the various aspects surrounding their data exchanges, as well as a new method for automating the system-level data-interchange software from system interfaces captured in this language. The advent of SIDL also contributes a new taxonomy providing a comprehensive perspective over system interoperability as well as a common language which can be shared amongst stakeholders, such as integrators, suppliers, and system experts. Being architecture-agnostic, SIDL provides a single architectural viewpoint overseeing all system interfaces and capturing multi-architecture considerations which was never achieved prior to this work. Furthermore, a SIDL code generator is introduced which has the novelty of generating the data-interchange software from a richer pool of information, notably from the high-level system relationships down to the low-level protocol and encoding details. Because multi-architecture considerations are captured natively in SIDL, this enables the code generator to be architecture-agnostic making it reusable in other contexts. This thesis also paves the way for future research building upon its contributions. It even proposes a vision for software application development with the end goal being to push further the boundaries of simplifying and automating the tasks involved in system integration and interoperability

A Software Product Line Approach to Ontology-based Recommendations in E-Tourism Systems

This study tackles two concerns of developers of Tourism Information Systems (TIS). First is the need for more dependable recommendation services due to the intangible nature of the tourism product where it is impossible for customers to physically evaluate the services on offer prior to practical experience. Second is the need to manage dynamic user requirements in tourism due to the advent of new technologies such as the semantic web and mobile computing such that etourism systems (TIS) can evolve proactively with emerging user needs at minimal time and development cost without performance tradeoffs. However, TIS have very predictable characteristics and are functionally identical in most cases with minimal variations which make them attractive for software product line development. The Software Product Line Engineering (SPLE) paradigm enables the strategic and systematic reuse of common core assets in the development of a family of software products that share some degree of commonality in order to realise a significant improvement in the cost and time of development. Hence, this thesis introduces a novel and systematic approach, called Product Line for Ontology-based Tourism Recommendation (PLONTOREC), a special approach focusing on the creation of variants of TIS products within a product line. PLONTOREC tackles the aforementioned problems in an engineering-like way by hybridizing concepts from ontology engineering and software product line engineering. The approach is a systematic process model consisting of product line management, ontology engineering, domain engineering, and application engineering. The unique feature of PLONTOREC is that it allows common TIS product requirements to be defined, commonalities and differences of content in TIS product variants to be planned and limited in advance using a conceptual model, and variant TIS products to be created according to a construction specification. We demonstrated the novelty in this approach using a case study of product line development of e-tourism systems for three countries in the West-African Region of Africa

Integration of Virtual Programming Lab in a process of teaching programming EduScrum based

Programming teaching is a key factor for technological evolution. The efficient way to learn to program is by programming and hard training and thus feedback is a crucial factor in the success and flow of the process. This work aims to analyse the potential use of VPL in the teaching process of programming in higher education. It also intends to verify whether, with VPL, it is possible to make students learning more effective and autonomous, with a reduction in the volume of assessment work by teachers. Experiments were carried out with the VPL, in the practical-laboratory classes of a curricular unit of initiation to programming in a higher education institution. The results supported by the responses to surveys, point to the validity of the model

A Weighted Grid for Measuring Program Robustness

Robustness is a key issue for all the programs, especially safety critical ones. In the literature, Program Robustness is defined as “the degree to which a system or component can function correctly in the presence of invalid input or stressful environment” (IEEE 1990). Robustness measurement is the value that reflects the Robustness Degree of the program. In this thesis, a new Robustness measurement technique; the Robustness Grid, is introduced. The Robustness Grid measures the Robustness Degree for programs, C programs in this instance, using a relative scale. It allows programmers to find the program’s vulnerable points, repair them, and avoid similar mistakes in the future. The Robustness Grid is a table that contains Language rules, which is classified into categories with respect to the program’s function names, and calculates the robustness degree. The Motor Industry Software Reliability Association (MISRA) C language rules with the Clause Program Slicing technique will be the basis for the robustness measurement mechanism. In the Robustness Grid, for every MISRA rule, a score will be given to a function every time it satisfies or violates a rule. Furthermore, Clause program slicing will be used to weight every MISRA rule to illustrate its importance in the program. The Robustness Grid shows how much each part of the program is robust and effective, and assists developers to measure and evaluate the robustness degree for each part of a program. Overall, the Robustness Grid is a new technique that measures the robustness of C programs using MISRA C rules and Clause program slicing. The Robustness Grid shows the program robustness degree and the importance of each part of the program. An evaluation of the Robustness Grid is performed to show that it offers new measurements that were not provided before