947 resultados para 005 Computer programming, programs
Resumo:
Les structures avec des lieurs sont trs communes en informatique. Les langages de programmation et les systmes logiques sont des exemples de structures avec des lieurs. La manipulation de lieurs est dlicate, de sorte que lcriture de programmes qui ma- nipulent ces structures tirerait profit dun soutien spcifique pour les lieurs. Lenviron- nement de programmation Beluga est un exemple dun tel systme. Nous dveloppons et prsentons ici un compilateur pour ce systme. Parmi les programmes pour lesquels Beluga est spcialement bien adapt, plusieurs peuvent bnficier dun compilateur. Par exemple, les programmes pour valider les types (les "type-checkers"), les compilateurs et les interprteurs tirent profit du soutien spcifique des lieurs et des types dpendants prsents dans le langage. Ils ncessitent tous galement une excution efficace, que lon propose dobtenir par le biais dun compilateur. Le but de ce travail est de prsenter un nouveau compilateur pour Beluga, qui emploie une reprsentation interne polyvalente et permet de partager du code entre plusieurs back-ends. Une contribution notable est la compilation du filtrage de Beluga, qui est particulirement puissante dans ce langage.
Resumo:
Un objectif principal du gnie logiciel est de pouvoir produire des logiciels complexes, de grande taille et fiables en un temps raisonnable. La technologie oriente objet (OO) a fourni de bons concepts et des techniques de modlisation et de programmation qui ont permis de dvelopper des applications complexes tant dans le monde acadmique que dans le monde industriel. Cette exprience a cependant permis de dcouvrir les faiblesses du paradigme objet (par exemples, la dispersion de code et le problme de traabilit). La programmation oriente aspect (OA) apporte une solution simple aux limitations de la programmation OO, telle que le problme des proccupations transversales. Ces proccupations transversales se traduisent par la dispersion du mme code dans plusieurs modules du systme ou lemmlement de plusieurs morceaux de code dans un mme module. Cette nouvelle mthode de programmer permet dimplmenter chaque problmatique indpendamment des autres, puis de les assembler selon des rgles bien dfinies. La programmation OA promet donc une meilleure productivit, une meilleure rutilisation du code et une meilleure adaptation du code aux changements. Trs vite, cette nouvelle faon de faire sest vue stendre sur tout le processus de dveloppement de logiciel en ayant pour but de prserver la modularit et la traabilit, qui sont deux proprits importantes des logiciels de bonne qualit. Cependant, la technologie OA prsente de nombreux dfis. Le raisonnement, la spcification, et la vrification des programmes OA prsentent des difficults dautant plus que ces programmes voluent dans le temps. Par consquent, le raisonnement modulaire de ces programmes est requis sinon ils ncessiteraient dtre rexamins au complet chaque fois quun composant est chang ou ajout. Il est cependant bien connu dans la littrature que le raisonnement modulaire sur les programmes OA est difficile vu que les aspects appliqus changent souvent le comportement de leurs composantes de base [47]. Ces mmes difficults sont prsentes au niveau des phases de spcification et de vrification du processus de dveloppement des logiciels. Au meilleur de nos connaissances, la spcification modulaire et la vrification modulaire sont faiblement couvertes et constituent un champ de recherche trs intressant. De mme, les interactions entre aspects est un srieux problme dans la communaut des aspects. Pour faire face ces problmes, nous avons choisi dutiliser la thorie des catgories et les techniques des spcifications algbriques. Pour apporter une solution aux problmes ci-dessus cits, nous avons utilis les travaux de Wiels [110] et dautres contributions telles que celles dcrites dans le livre [25]. Nous supposons que le systme en dveloppement est dj dcompos en aspects et classes. La premire contribution de notre thse est lextension des techniques des spcifications algbriques la notion daspect. Deuximement, nous avons dfini une logique, LA , qui est utilise dans le corps des spcifications pour dcrire le comportement de ces composantes. La troisime contribution consiste en la dfinition de loprateur de tissage qui correspond la relation dinterconnexion entre les modules daspect et les modules de classe. La quatrime contribution concerne le dveloppement dun mcanisme de prvention qui permet de prvenir les interactions indsirables dans les systmes orients aspect.
Resumo:
La programmation linaire en nombres entiers est une approche robuste qui permet de rsoudre rapidement de grandes instances de problmes d'optimisation discrte. Toutefois, les problmes gagnent constamment en complexit et imposent parfois de fortes limites sur le temps de calcul. Il devient alors ncessaire de dvelopper des mthodes spcialises afin de rsoudre approximativement ces problmes, tout en calculant des bornes sur leurs valeurs optimales afin de prouver la qualit des solutions obtenues. Nous proposons d'explorer une approche de reformulation en nombres entiers guide par la relaxation lagrangienne. Aprs l'identification d'une forte relaxation lagrangienne, un processus systmatique permet d'obtenir une seconde formulation en nombres entiers. Cette reformulation, plus compacte que celle de Dantzig et Wolfe, comporte exactement les mmes solutions entires que la formulation initiale, mais en amliore la borne linaire: elle devient gale la borne lagrangienne. L'approche de reformulation permet d'unifier et de gnraliser des formulations et des mthodes de borne connues. De plus, elle offre une manire simple d'obtenir des reformulations de moins grandes tailles en contrepartie de bornes plus faibles. Ces reformulations demeurent de grandes tailles. C'est pourquoi nous dcrivons aussi des mthodes spcialises pour en rsoudre les relaxations linaires. Finalement, nous appliquons l'approche de reformulation deux problmes de localisation. Cela nous mne de nouvelles formulations pour ces problmes; certaines sont de trs grandes tailles, mais nos mthodes de rsolution spcialises les rendent pratiques.
Resumo:
Modern computer systems are plagued with stability and security problems: applications lose data, web servers are hacked, and systems crash under heavy load. Many of these problems or anomalies arise from rare program behavior caused by attacks or errors. A substantial percentage of the web-based attacks are due to buffer overflows. Many methods have been devised to detect and prevent anomalous situations that arise from buffer overflows. The current state-of-art of anomaly detection systems is relatively primitive and mainly depend on static code checking to take care of buffer overflow attacks. For protection, Stack Guards and I-leap Guards are also used in wide varieties.This dissertation proposes an anomaly detection system, based on frequencies of system calls in the system call trace. System call traces represented as frequency sequences are profiled using sequence sets. A sequence set is identified by the starting sequence and frequencies of specific system calls. The deviations of the current input sequence from the corresponding normal profile in the frequency pattern of system calls is computed and expressed as an anomaly score. A simple Bayesian model is used for an accurate detection.Experimental results are reported which show that frequency of system calls represented using sequence sets, captures the normal behavior of programs under normal conditions of usage. This captured behavior allows the system to detect anomalies with a low rate of false positives. Data are presented which show that Bayesian Network on frequency variations responds effectively to induced buffer overflows. It can also help administrators to detect deviations in program flow introduced due to errors.
Resumo:
In this publication, we report on an online survey that was carried out among parallel programmers. More than 250 people worldwide have submitted answers to our questions, and their responses are analyzed here. Although not statistically sound, the data we provide give useful insights about which parallel programming systems and languages are known and in actual use. For instance, the collected data indicate that for our survey group MPI and (to a lesser extent) C are the most widely used parallel programming system and language, respectively.
Resumo:
Genetic programming is known to provide good solutions for many problems like the evolution of network protocols and distributed algorithms. In such cases it is most likely a hardwired module of a design framework that assists the engineer to optimize specific aspects of the system to be developed. It provides its results in a fixed format through an internal interface. In this paper we show how the utility of genetic programming can be increased remarkably by isolating it as a component and integrating it into the model-driven software development process. Our genetic programming framework produces XMI-encoded UML models that can easily be loaded into widely available modeling tools which in turn posses code generation as well as additional analysis and test capabilities. We use the evolution of a distributed election algorithm as an example to illustrate how genetic programming can be combined with model-driven development. This example clearly illustrates the advantages of our approach the generation of source code in different programming languages.
Resumo:
Das hier frei verfgbare Skript und die Sammlung an Klausuren mit Musterlsungen aus den Jahren 2005 bis 2015 geht auf die gleichnamige Vorlesung im Masterstudium Informatik an der Universitt Kassel zurck. Kenntnisse in der Programmierung graphischer Oberflchen sind offensichtlich sehr ntzlich, da es kaum noch Anwendungen gibt, die auf eine ansprechend gestaltete Benutzeroberflche verzichten knnen. Andererseits ist die Programmierung auch heute noch sehr aufwendig. Als Ausweg empfiehlt sich die Beschftigung mit Ousterhouts Tcl/Tk, das einerseits eine leicht lernbare und universell einsetzbare Skriptsprache (Tcl) bietet, andererseits mit Tk ber einen berschaubaren und auf fast allen Betriebssystemen einsetzbaren Werkzeugkasten fr die Konstruktion graphischer Oberflchen verfgt. Grundlage des Skripts ist das ausgezeichnete Buch von Harrison und McLennan Effective Tcl/Tk Programming - Writing Better Programs with Tcl and Tk aus dem Jahr 1998, das inzwischen auch in einer deutschen bersetzung vorliegt.
Resumo:
Computational models are arising is which programs are constructed by specifying large networks of very simple computational devices. Although such models can potentially make use of a massive amount of concurrency, their usefulness as a programming model for the design of complex systems will ultimately be decided by the ease in which such networks can be programmed (constructed). This thesis outlines a language for specifying computational networks. The language (AFL-1) consists of a set of primitives, ad a mechanism to group these elements into higher level structures. An implementation of this language runs on the Thinking Machines Corporation, Connection machine. Two significant examples were programmed in the language, an expert system (CIS), and a planning system (AFPLAN). These systems are explained and analyzed in terms of how they compare with similar systems written in conventional languages.
Resumo:
This paper describes a system for the computer understanding of English. The system answers questions, executes commands, and accepts information in normal English dialog. It uses semantic information and context to understand discourse and to disambiguate sentences. It combines a complete syntactic analysis of each sentence with a "heuristic understander" which uses different kinds of information about a sentence, other parts of the discourse, and general information about the world in deciding what the sentence means. It is based on the belief that a computer cannot deal reasonably with language unless it can "understand" the subject it is discussing. The program is given a detailed model of the knowledge needed by a simple robot having only a hand and an eye. We can give it instructions to manipulate toy objects, interrogate it about the scene, and give it information it will use in deduction. In addition to knowing the properties of toy objects, the program has a simple model of its own mentality. It can remember and discuss its plans and actions as well as carry them out. It enters into a dialog with a person, responding to English sentences with actions and English replies, and asking for clarification when its heuristic programs cannot understand a sentence through use of context and physical knowledge.
Resumo:
The furious pace of Moore's Law is driving computer architecture into a realm where the the speed of light is the dominant factor in system latencies. The number of clock cycles to span a chip are increasing, while the number of bits that can be accessed within a clock cycle is decreasing. Hence, it is becoming more difficult to hide latency. One alternative solution is to reduce latency by migrating threads and data, but the overhead of existing implementations has previously made migration an unserviceable solution so far. I present an architecture, implementation, and mechanisms that reduces the overhead of migration to the point where migration is a viable supplement to other latency hiding mechanisms, such as multithreading. The architecture is abstract, and presents programmers with a simple, uniform fine-grained multithreaded parallel programming model with implicit memory management. In other words, the spatial nature and implementation details (such as the number of processors) of a parallel machine are entirely hidden from the programmer. Compiler writers are encouraged to devise programming languages for the machine that guide a programmer to express their ideas in terms of objects, since objects exhibit an inherent physical locality of data and code. The machine implementation can then leverage this locality to automatically distribute data and threads across the physical machine by using a set of high performance migration mechanisms. An implementation of this architecture could migrate a null thread in 66 cycles -- over a factor of 1000 improvement over previous work. Performance also scales well; the time required to move a typical thread is only 4 to 5 times that of a null thread. Data migration performance is similar, and scales linearly with data block size. Since the performance of the migration mechanism is on par with that of an L2 cache, the implementation simulated in my work has no data caches and relies instead on multithreading and the migration mechanism to hide and reduce access latencies.
Resumo:
We present a type-based approach to statically derive symbolic closed-form formulae that characterize the bounds of heap memory usages of programs written in object-oriented languages. Given a program with size and alias annotations, our inference system will compute the amount of memory required by the methods to execute successfully as well as the amount of memory released when methods return. The obtained analysis results are useful for networked devices with limited computational resources as well as embedded software.
Resumo:
A key capability of data-race detectors is to determine whether one thread executes logically in parallel with another or whether the threads must operate in series. This paper provides two algorithms, one serial and one parallel, to maintain series-parallel (SP) relationships "on the fly" for fork-join multithreaded programs. The serial SP-order algorithm runs in O(1) amortized time per operation. In contrast, the previously best algorithm requires a time per operation that is proportional to Tarjans functional inverse of Ackermanns function. SP-order employs an order-maintenance data structure that allows us to implement a more efficient "English-Hebrew" labeling scheme than was used in earlier race detectors, which immediately yields an improved determinacy-race detector. In particular, any fork-join program running in T time on a single processor can be checked on the fly for determinacy races in O(T) time. Corresponding improved bounds can also be obtained for more sophisticated data-race detectors, for example, those that use locks. By combining SP-order with Feng and Leisersons serial SP-bags algorithm, we obtain a parallel SP-maintenance algorithm, called SP-hybrid. Suppose that a fork-join program has n threads, T work, and a critical-path length of T[subscript ]. When executed on P processors, we prove that SP-hybrid runs in O((T/P + PT[subscript ]) lg n) expected time. To understand this bound, consider that the original program obtains linear speed-up over a 1-processor execution when P = O(T/T[subscript ]). In contrast, SP-hybrid obtains linear speed-up when P = O(T/T[subscript ]), but the work is increased by a factor of O(lg n).
Resumo:
The underlying assumptions for interpreting the meaning of data often change over time, which further complicates the problem of semantic heterogeneities among autonomous data sources. As an extension to the COntext INterchange (COIN) framework, this paper introduces the notion of temporal context as a formalization of the problem. We represent temporal context as a multi-valued method in F-Logic; however, only one value is valid at any point in time, the determination of which is constrained by temporal relations. This representation is then mapped to an abductive constraint logic programming framework with temporal relations being treated as constraints. A mediation engine that implements the framework automatically detects and reconciles semantic differences at different times. We articulate that this extended COIN framework is suitable for reasoning on the Semantic Web.
Resumo:
The underlying assumptions for interpreting the meaning of data often change over time, which further complicates the problem of semantic heterogeneities among autonomous data sources. As an extension to the COntext INterchange (COIN) framework, this paper introduces the notion of temporal context as a formalization of the problem. We represent temporal context as a multi-valued method in F-Logic; however, only one value is valid at any point in time, the determination of which is constrained by temporal relations. This representation is then mapped to an abductive constraint logic programming framework with temporal relations being treated as constraints. A mediation engine that implements the framework automatically detects and reconciles semantic differences at different times. We articulate that this extended COIN framework is suitable for reasoning on the Semantic Web.
Resumo:
The underlying assumptions for interpreting the meaning of data often change over time, which further complicates the problem of semantic heterogeneities among autonomous data sources. As an extension to the COntext INterchange (COIN) framework, this paper introduces the notion of temporal context as a formalization of the problem. We represent temporal context as a multi-valued method in F-Logic; however, only one value is valid at any point in time, the determination of which is constrained by temporal relations. This representation is then mapped to an abductive constraint logic programming framework with temporal relations being treated as constraints. A mediation engine that implements the framework automatically detects and reconciles semantic differences at different times. We articulate that this extended COIN framework is suitable for reasoning on the Semantic Web.
