Diderot, le grand satirique

Diderot est davantage un humaniste et un non-conformiste qui se préoccupe beaucoup de la stabilité et du confort de l‘existence humaine. Il croit que l‘homme est né pour vivre en société et qu‘il doit être heureux. Toute cette philosophie ressort de ses oeuvres dont l‘objectif est celui d‘aider les hommes à atteindre le bonheur: il s‘agit donc d‘une littérature engagée. La verve satirique de Diderot est le fil directeur d‘une oeuvre variée et diverse qui risque de décourager le lecteur paresseux. L‘élément satirique rassemble les articles de L‟Encyclopédie, les Salons et les oeuvres fictives de Diderot, comme par exemple, Le Neveu de Rameau, Jacques le Fataliste et son Maître et La Religieuse. Bien que L‟Encyclopédie soit une entreprise scientifique, Diderot cache, dans plusieurs articles, pour tromper la censure, des attaques virulentes contre la morale, la religion et ses institutions. Il critique aussi les superstitions et les croyances don‘t s‘entourent les religions. Dans les Salons, Diderot rédige des appréciations sur les tableaux de quelques peintres, parus dans plusieurs expositions. Mais Diderot ne les décrit pas en tant que technicien, il s‘en sert pour faire une parodie de ces peintures, utilisant très souvent un langage grossier et un style gaillard. La satire est le lien entre la non-fiction et la fiction. Dans ses oeuvres romanesques on trouve la satire sociale et littéraire : Diderot y met en question le genre romanesque traditionnel, par conséquent Le Neveu de Rameau, Jacques le Fataliste et son Maître et La Religieuse se caractérisent par un décousu apparent et désordonné – c‘est la forme amusante dont Diderot se sert pour révéler aux lecteurs que les romans traditionnels les trompent. La forme désorganisée sert aussi à montrer le manque de liberté dont l‘homme jouit – l‘homme n‘est qu‘un guignol manipulé par le destin. En effet, en « déconstruisant » le roman, Diderot oblige le lecteur à réfléchir sur la condition humaine et l‘illusion romanesque de telle façon que le lecteur ne sait plus ce qui est faux et ce qui est vrai, surtout dans le cas de La Religieuse.

An improved preemption delay upper bound for floating non-preemptive region

In embedded systems, the timing behaviour of the control mechanisms are sometimes of critical importance for the operational safety. These high criticality systems require strict compliance with the offline predicted task execution time. The execution of a task when subject to preemption may vary significantly in comparison to its non-preemptive execution. Hence, when preemptive scheduling is required to operate the workload, preemption delay estimation is of paramount importance. In this paper a preemption delay estimation method for floating non-preemptive scheduling policies is presented. This work builds on [1], extending the model and optimising it considerably. The preemption delay function is subject to a major tightness improvement, considering the WCET analysis context. Moreover more information is provided as well in the form of an extrinsic cache misses function, which enables the method to provide a solution in situations where the non-preemptive regions sizes are small. Finally experimental results from the implementation of the proposed solutions in Heptane are provided for real benchmarks which validate the significance of this work.

Response time analysis of COTS-Based multicores considering the contention on the shared memory bus

The current industry trend is towards using Commercially available Off-The-Shelf (COTS) based multicores for developing real time embedded systems, as opposed to the usage of custom-made hardware. In typical implementation of such COTS-based multicores, multiple cores access the main memory via a shared bus. This often leads to contention on this shared channel, which results in an increase of the response time of the tasks. Analyzing this increased response time, considering the contention on the shared bus, is challenging on COTS-based systems mainly because bus arbitration protocols are often undocumented and the exact instants at which the shared bus is accessed by tasks are not explicitly controlled by the operating system scheduler; they are instead a result of cache misses. This paper makes three contributions towards analyzing tasks scheduled on COTS-based multicores. Firstly, we describe a method to model the memory access patterns of a task. Secondly, we apply this model to analyze the worst case response time for a set of tasks. Although the required parameters to obtain the request profile can be obtained by static analysis, we provide an alternative method to experimentally obtain them by using performance monitoring counters (PMCs). We also compare our work against an existing approach and show that our approach outperforms it by providing tighter upper-bound on the number of bus requests generated by a task.

A parallel programming model for ada

Over the last three decades, computer architects have been able to achieve an increase in performance for single processors by, e.g., increasing clock speed, introducing cache memories and using instruction level parallelism. However, because of power consumption and heat dissipation constraints, this trend is going to cease. In recent times, hardware engineers have instead moved to new chip architectures with multiple processor cores on a single chip. With multi-core processors, applications can complete more total work than with one core alone. To take advantage of multi-core processors, parallel programming models are proposed as promising solutions for more effectively using multi-core processors. This paper discusses some of the existent models and frameworks for parallel programming, leading to outline a draft parallel programming model for Ada.

Finding an upper bound on the increase in execution time due to contention on the memory bus in COTS-based multicore systems

Contention on the memory bus in COTS based multicore systems is becoming a major determining factor of the execution time of a task. Analyzing this extra execution time is non-trivial because (i) bus arbitration protocols in such systems are often undocumented and (ii) the times when the memory bus is requested to be used are not explicitly controlled by the operating system scheduler; they are instead a result of cache misses. We present a method for finding an upper bound on the extra execution time of a task due to contention on the memory bus in COTS based multicore systems. This method makes no assumptions on the bus arbitration protocol (other than assuming that it is work-conserving).

CPMD-mindful task assignment for NPS-F

The multiprocessor scheduling scheme NPS-F for sporadic tasks has a high utilisation bound and an overall number of preemptions bounded at design time. NPS-F binpacks tasks offline to as many servers as needed. At runtime, the scheduler ensures that each server is mapped to at most one of the m processors, at any instant. When scheduled, servers use EDF to select which of their tasks to run. Yet, unlike the overall number of preemptions, the migrations per se are not tightly bounded. Moreover, we cannot know a priori which task a server will be currently executing at the instant when it migrates. This uncertainty complicates the estimation of cache-related preemption and migration costs (CPMD), potentially resulting in their overestimation. Therefore, to simplify the CPMD estimation, we propose an amended bin-packing scheme for NPS-F allowing us (i) to identify at design time, which task migrates at which instant and (ii) bound a priori the number of migrating tasks, while preserving the utilisation bound of NPS-F.

A adequação da oferta formativa dos cursos profissionais às necessidades do mercado de trabalho

Este estudo tem como objetivo principal analisar a oferta formativa a nível dos cursos profissionais e a sua adequação ao mercado de trabalho. Nesse sentido, analisou-se a evolução do ensino profissional em Portugal, nomeadamente em escolas públicas. A abertura das escolas secundárias da rede pública à educação e formação profissional tornou-se um facto incontornável, com a última revisão curricular do ensino secundário a permitir um arrojado salto no desenvolvimento, ao qual não é alheia a sua crescente valorização e consolidação no contexto da ação educativa. As sucessivas reformas do Ensino Secundário, também foram objeto de exploração deste trabalho. Ao longo das décadas, repercutiram-se várias reformas das políticas educativas que, entretanto, culminando na Reforma do Ensino Secundário, em 2004, assumiram a importância do ensino profissionalmente qualificante, com uma expressão no sistema educativo mais intensa que nunca. Neste estudo participaram alunos de um curso profissional, a Coordenadora do Agrupamento de Escolas e a Coordenadora da Associação Empresarial inquiridos sobre as representações que fazem sobre a oferta formativa disponibilizada e a da sua adequação ao mercado empresarial. O presente estudo permitiu perceber que a Escola não possui uma relação objetiva com o mercado empresarial, mas que os alunos têm vontade de se integrar numa empresa da sua região. O resultado do estudo aponta para a existência de uma oferta formativa que não parece estar adequada às necessidades do mercado de trabalho local.

An aspect-oriented framework for orthogonal persistence

The life cycle of software applications in general is very short and with extreme volatile requirements. Within these conditions programmers need development tools and techniques with an extreme level of productivity. We consider the code reuse as the most prominent approach to solve that problem. Our proposal uses the advantages provided by the Aspect-Oriented Programming in order to build a reusable framework capable to turn both programmer and application oblivious as far as data persistence is concerned, thus avoiding the need to write any line of code about that concern. Besides the benefits to productivity, the software quality increases. This paper describes the actual state of the art, identifying the main challenge to build a complete and reusable framework for Orthogonal Persistence in concurrent environments with support for transactions. The present work also includes a successfully developed prototype of that framework, capable of freeing the programmer of implementing any read or write data operations. This prototype is supported by an object oriented database and, in the future, will also use a relational database and have support for transactions.

Transactions and schema evolution in a persistent object-oriented programming system

Applications are subject of a continuous evolution process with a profound impact on their underlining data model, hence requiring frequent updates in the applications' class structure and database structure as well. This twofold problem, schema evolution and instance adaptation, usually known as database evolution, is addressed in this thesis. Additionally, we address concurrency and error recovery problems with a novel meta-model and its aspect-oriented implementation. Modern object-oriented databases provide features that help programmers deal with object persistence, as well as all related problems such as database evolution, concurrency and error handling. In most systems there are transparent mechanisms to address these problems, nonetheless the database evolution problem still requires some human intervention, which consumes much of programmers' and database administrators' work effort. Earlier research works have demonstrated that aspect-oriented programming (AOP) techniques enable the development of flexible and pluggable systems. In these earlier works, the schema evolution and the instance adaptation problems were addressed as database management concerns. However, none of this research was focused on orthogonal persistent systems. We argue that AOP techniques are well suited to address these problems in orthogonal persistent systems. Regarding the concurrency and error recovery, earlier research showed that only syntactic obliviousness between the base program and aspects is possible. Our meta-model and framework follow an aspect-oriented approach focused on the object-oriented orthogonal persistent context. The proposed meta-model is characterized by its simplicity in order to achieve efficient and transparent database evolution mechanisms. Our meta-model supports multiple versions of a class structure by applying a class versioning strategy. Thus, enabling bidirectional application compatibility among versions of each class structure. That is to say, the database structure can be updated because earlier applications continue to work, as well as later applications that have only known the updated class structure. The specific characteristics of orthogonal persistent systems, as well as a metadata enrichment strategy within the application's source code, complete the inception of the meta-model and have motivated our research work. To test the feasibility of the approach, a prototype was developed. Our prototype is a framework that mediates the interaction between applications and the database, providing them with orthogonal persistence mechanisms. These mechanisms are introduced into applications as an {\it aspect} in the aspect-oriented sense. Objects do not require the extension of any super class, the implementation of an interface nor contain a particular annotation. Parametric type classes are also correctly handled by our framework. However, classes that belong to the programming environment must not be handled as versionable due to restrictions imposed by the Java Virtual Machine. Regarding concurrency support, the framework provides the applications with a multithreaded environment which supports database transactions and error recovery. The framework keeps applications oblivious to the database evolution problem, as well as persistence. Programmers can update the applications' class structure because the framework will produce a new version for it at the database metadata layer. Using our XML based pointcut/advice constructs, the framework's instance adaptation mechanism is extended, hence keeping the framework also oblivious to this problem. The potential developing gains provided by the prototype were benchmarked. In our case study, the results confirm that mechanisms' transparency has positive repercussions on the programmer's productivity, simplifying the entire evolution process at application and database levels. The meta-model itself also was benchmarked in terms of complexity and agility. Compared with other meta-models, it requires less meta-object modifications in each schema evolution step. Other types of tests were carried out in order to validate prototype and meta-model robustness. In order to perform these tests, we used an OO7 small size database due to its data model complexity. Since the developed prototype offers some features that were not observed in other known systems, performance benchmarks were not possible. However, the developed benchmark is now available to perform future performance comparisons with equivalent systems. In order to test our approach in a real world scenario, we developed a proof-of-concept application. This application was developed without any persistence mechanisms. Using our framework and minor changes applied to the application's source code, we added these mechanisms. Furthermore, we tested the application in a schema evolution scenario. This real world experience using our framework showed that applications remains oblivious to persistence and database evolution. In this case study, our framework proved to be a useful tool for programmers and database administrators. Performance issues and the single Java Virtual Machine concurrent model are the major limitations found in the framework.