Les technologies omniprésentes dans notre environnement intègrent des éléments logiciels facilitant leur utilisation. Ces technologies offrent un vaste laboratoire d'expérimentation pour la recherche et en particulier pour l'informatique appliquée. Ces technologies sont un support évident pour rendre des services aux personnes dans leur vie quotidienne. Ces services concernent divers champs d'applications, chacun servant des objectifs spécifiques : confort, sécurité, accès à l'information ou encore assistance à la personne. Puisque les applications offrant ces services sont intimement liées aux besoins des utilisateurs, il est indispensable qu'elles s'adaptent facilement à leurs besoins. Une manière de répondre à ce défi est de proposer à l'utilisateur des outils pour programmer lui-même ses applications. Notre contribution consiste non seulement à définir un tel outil, sous la forme d'un langage visuel paramétré par un champ d'applications, mais aussi à proposer une méthodologie dont l'objectif est de guider un utilisateur dans la programmation d'applications à l'aide de ce langage. Cette méthodologie est dédiée à l'orchestration d'entités communicantes : elles représentent les technologies déployées dans nos environnements. Notre approche, associant une méthodologie à un langage, est accessible à un programmeur novice et suffisamment expressive pour traiter divers champs d'applications. Afin d'augmenter la confiance de l'utilisateur dans le développement de ses applications, nous étendons la méthodologie en proposant une approche de développement dirigée par la vérification de quelques propriétés. Cette vérification est permise par la sémantique du langage, formellement définie.

Mobile devices connected to cloud based services are becoming a mainstream method of delivery up-to-date and context aware information to users. Connecting mobile applications to cloud service require significant developer effort. Yet this communication code usually follows certain patterns, varying accordingly to the specific type of data sent and received from the server. By analyzing the causes of theses variations, we can create a system that can automate the code creation for communication from a mobile device to a cloud server. To automate code creation, a general pattern must extracted. This general solution can then be applied to any database configuration. Automating this process frees up valuable development time, allowing developers to make other parts of the application and/or backend service a better experience for the end user.

[pt] Um cenário comum atualmente é o de aplicações desenvolvidas usando duas linguagens de programação a fim de otimizar partes onde o desempenho é crítico e permitir extensibilidade através de scripts escritos pelo usuário. Há várias formas de se obter esse tipo de interoperabilidade; idealmente, entretanto, uma linguagem deve prover uma interface de acesso externo (foreign language interface, FLI) que permita ao programador receber e enviar tanto chamadas como dados para outra linguagem. Este trabalho discute as principais questões envolvendo o projeto de APIs para integração de ambientes de execução de linguagens em aplicações C. Apresentamos os principais problemas enfrentados na interação entre código executando em um ambiente com características inerentemente dinâmicas como o de uma linguagem de script com código C. Comparamos aqui as abordagens empregadas por cinco linguagens no tratamento da comunicação entre os espaços de dados de C e do ambiente de execução embutido e as conseqüências destas abordagens no gerenciamento de memória, bem como no compartilhamento de código entre a aplicação C e o da linguagem de script. Ilustramos as diferenças das APIs destas linguagens e o impacto destas no código resultante de uma aplicação C através de um estudo de caso. Diferentes linguagens de script são embutidas como plugins de uma mesma biblioteca, que por sua vez expõe a aplicações clientes uma API genérica de scripting. Assim, o código de cada plugin permite observar de forma clara e isolada os procedimentos adotados em cada linguagem para chamada de funções, registro de funçoes C e conversão de dados entre os ambientes. / [en] Applications written in two programming languages, in order to optimize parts where performance is critical or to obtain extensibility through userwritten scripts, are commonplace nowadays. There are several ways to obtain this kind of interoperability; ideally, however, a language should provide a foreign language interface (FLI), allowing the programmer to send and receive both data and function calls to the external language. This work discusses the main issues involving the design of APIs for the integration of language environments within C applications. We present the main problems faced in the interaction between code executed in an environment with inherently dynamic characteristics such as a scripting language and C code. We compare the approaches employed by five languages when handling communication between the data spaces of C and the embedded runtime environment and the consequences of these approaches in memory management, as well as sharing of code between the C application and that from the scripting language. We illustrate the differences of the APIs of those languages and their impact in the resulting code of a C application through a case study. Different scripting languages were embedded as plugins for a library, which on its turn exposes to client applications a generic scripting API. This way, the code of each plugin allows us to observe in a clear and isolated way the procedures adopted by each language for function calls, registration of C functions and conversion of data between the environments.

Thesis (M.S.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1982. / MICROFICHE COPY AVAILABLE IN ARCHIVES AND ENGINEERING / Includes bibliographical references. / by Poh Chuan Lim. / M.S.

Made available in DSpace on 2015-03-05T13:58:26Z (GMT). No. of bitstreams: 0 Previous issue date: 15 / Nenhuma / A rápida popularização de dispositivos computacionais cada vez mais poderosos está trazendo a computação móvel para um grande número de pessoas. Na medida em que os dispositivos ganham mais poder computacional, diferentes aplicações podem ser desenvolvidas de modo a atender as necessidades de um número cada vez maior de usuários. Esta evolução, entretanto, não é livre de desafios. Com o aumento do número de usuários, a demanda por customização torna-se uma questão chave. Entre as soluções que oferecem a customização encontra-se a mobilidade de código. Neste sentido esta dissertação apresenta um modelo de mobilidade forte de código orientado ao Holoparadigma. Até então somente a mobilidade lógica era suportada, estando à mobilidade de código apenas na especificação. Este modelo é chamado HoloGo e foi desenvolvido tendo como base a HoloVM, uma máquina virtual com suporte a blackboards e programação concorrente. A validação deste modelo ocorreu através da implementação de um protótipo que foi utilizado no desen / The rapid popularization of increasingly powerful computational devices is setting the mobile computing into daily life of a great number of people. As devices evolve along with its computational power, many applications can be developed in order to accomplish the different needs of a growing number of users. This evolution, however, it is not free of challenges. As the number of users increase, the need of customization becomes a major concern. Among the solutions that offer customization to software applications is code mobility. In this way, this dissertation presents a strong code mobility model focused in the Holoparadigm. Until now only logical mobility was provided, being the code mobility only in the specification. This model is called HoloGo and was developed on top of HoloVM, a virtual machine with blackboards and concurrent programming support. HoloGo was validated through the implementation of a prototype used in the development of applications that use code mobility. In this context, the main con

Thesis (Ph.D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1982. / MICROFICHE COPY AVAILABLE IN ARCHIVES AND ENGINEERING / Bibliography: leaves 180-184. / by William Arthur Kornfeld. / Ph.D.

Distributed-memory machines offer a very high level of performance, flexibility and scalability. But the memory organization of this kind of machine determines that processes on different processors must communicate explicitly by sending and receiving messages. As a result, the programmer faces the enormously difficult task of detailed planning of algorithm-irrelevant, low-level communication issues. This level of programming resembles writing assembly programs for a sequential machine. ACE is a message-passing language with abstract communication statements. It was defined by Dr. Jingke Li at Portland State University. The communication in ACE is still explicit, but it is abstracted to a higher level. The abstraction can help balance the needs of ease of programming and high performance. This thesis discusses how those high-level communication abstractions can be transformed into low-level communication routines. It presents the design and implementation of a compiler that transforms an ACE program into a C program with low-level communication routines. The compiler is implemented for the Intel iPSC/2 hypercube multiprocessor machine. Compared to their low-level counterparts, ACE programs are easier to write and are more understandable. Compared to their high level counterparts, more efficient code can be generated since the communication information is expressed explicitly in ACE and the compiler itself is much less complex. ACE also enables the users to fine tune some critical communication segments. Some well known parallel algorithms written in ACE are compiled by the compiler as examples, and experimental results of their performance are included.

La plupart des programmes informatiques sont concurrents : ils doivent effectuer plusieurs tâches en même temps. Les threads et les événements sont deux techniques usuelles d'implémentation de la concurrence. Les événements sont généralement plus légers et efficaces que les threads, mais aussi plus difficiles à utiliser. De plus, ils sont souvent trop limités ; il est alors nécessaire d'écrire du code hybride, encore plus complexe, utilisant à la fois des threads ordonnancés préemptivement et des événements ordonnancés coopérativement. Nous montrons dans cette thèse que des programmes concurrents écrits dans un style à threads sont traduisibles automatiquement en programmes à événements équivalents et efficaces par une suite de transformations source-source prouvées. Nous proposons d'abord Continuation-Passing C, une extension du langage C pour l'écriture de systèmes concurrents qui offre des threads très légers et unifiés (coopératifs et préemptifs). Les programmes CPC sont transformés par le traducteur CPC pour produire du code à événements séquentialisé efficace, utilisant des threads natifs pour les parties préemptives. Nous définissons et prouvons ensuite la correction de ces transformations, en particulier le lambda lifting et la conversion CPS, pour un langage impératif. Enfin, nous validons la conception et l'implémentation de CPC en le comparant à d'autres bibliothèques de threads et en exhibant notre seeder BitTorrent Hekate. Nous justifions aussi notre choix du lambda lifting en implémentant eCPC, une variante de CPC utilisant les environnements, et en comparant ses performances à celles de CPC.

Nous nous intéressons à la conception sûre de systèmes répartis. Nous montrons qu'avec la complexité et l'intégration croissante des systèmes embarqués, la structure fonctionnelle du système peut entrer en conflit avec la structure de son architecture. L'approche traditionnelle de conception par raffinement de cette architecture compromet alors la modularité fonctionnelle du système. Nous proposons donc une méthode permettant de concevoir un système réparti défini comme un programme unique, dont la structure fonctionnelle est indépendante de l'architecture du système. Cette méthode est basée sur l'ajout de primitives de répartition à un langage flots de données synchrone. Ces primitives permettent d'une part de déclarer l'architecture sous la forme d'un graphe définissant les ressources existantes et les liens de communication existant entre ces ressources, et d'autre part de spécifier par des annotations la localisation de certaines valeurs et calculs du programme. Nous définissons ensuite la sémantique formelle de ce langage étendu. Cette sémantique a pour but de rendre compte de manière formelle l'effet des annotations ajoutées par le programmeur. Un système de types à effets permet ensuite de vérifier la cohérence de ces annotations. Ce système de types est muni d'un mécanisme d'inférence, qui permet d'inférer, à partir des annotations du programmeur, la localisation des calculs non annotés. Nous définissons ensuite, à partir de ce système de types, une méthode de répartition automatique permettant d'obtenir, à partir d'un programme annoté, un fragment de programme par ressource de l'architecture. La correction du système de types avec la sémantique du langage est prouvée, ainsi que l'équivalence sémantique de l'exécution des fragments obtenus par la méthode de répartition automatique avec le programme initial. Cette méthode a été implémentée dans le compilateur du langage Lucid Synchrone, et testée sur un exemple de radio logicielle.

As the development of hardware progresses, computers are expected to solve increasingly complex problems. However, solving more complex problems requires more complex software. To be able to develop these software systems, new programming languages with new features and higher abstraction levels are introduced. These features are designed to ease development, but sometimes they also make the runtime behavior unpredictable. Such features can not be used in real-time systems. A feature that traditionally has been unpredictable is garbage collection. Moreover, even though a garbage collector frees unused memory, almost all such methods require large amounts of additional memory. Garbage collection relieves developers of the responsibility to reclaim memory that is no longer used by the application. This is very tedious and error prone if done manually. Since garbage collection increases productivity and decreases programming errors, developers find it attractive, also in the real-time domain. This thesis presents a predictable garbage collection method, real-time reference counting, that increases memory efficiency by about 50 % compared to the most memory efficient previously presented predictable garbage collector. To increase performance, an optimization technique called object ownership that eliminates redundant reference count updates is presented. Object ownership is designed for reference counters, but can also be used to increase the performance of other incremental garbage collectors. Finally, a static garbage collector is presented. The static garbage collector can allocate objects statically or on the runtime stack, and insert explicit instructions to reclaim memory allocated on the heap. It makes it possible to eliminate the need for runtime garbage collection for a large class of Java applications. The static garbage collection method can also be used to remove costly synchronization instructions. Competing static garbage collection methods with reasonable analysis time are restricted to stack allocation, and thus handle a smaller class of applications.