Programmation orientée prototype

Résumé

La programmation orientée prototype est une forme de programmation orientée objet sans classe, fondée sur la notion de prototype. Un prototype est un objet à partir duquel on crée de nouveaux objets. Dans le langage de programmation orientée prototype Self, les propriétés d'un objet, qu'elles renvoient à des attributs ou à des méthodes, sont appelés slots ; il n'y a pas la même distinction entre les slots de données et les slots de code qu'on a avec les classes. La grande différence avec la programmation objet à classe est qu'on peut remplacer le contenu des slots, en ajouter d'autres ou changer la hiérarchie d'héritage que cela soit prévu dans l'objet original ou pas. Self fut le premier langage à prototypes. Il a été conçu dans les laboratoires de Sun dans les années 1990. Le plus connu actuellement est JavaScript. Comparaison des modèles à classes et à prototypes Objets à classes :

Une classe définie par son code source est statique ;
Elle représente une définiti

Source officielle

https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_prototype

À propos de ce résultat

Cette page est générée automatiquement et peut contenir des informations qui ne sont pas correctes, complètes, à jour ou pertinentes par rapport à votre recherche. Il en va de même pour toutes les autres pages de ce site. Veillez à vérifier les informations auprès des sources officielles de l'EPFL.

Publications associées (8)

Publications associées

Chargement

Personnes associées (2)

Personnes associées

Chargement

Unités associées (1)

Unités associées

Chargement

Concepts associés (15)

Concepts associés

Chargement

Cours associés (8)

Cours associés

Chargement

Séances de cours associées (8)

Séances de cours associées

Chargement

Development of a motorized binding for ski touring auto-adapting its height with the slope

Sébastien Allemand

The idea is to integrate a rotating or linear motor in a touring ski binding and automatically adapt the heel height according to the slope the user is mounting. This would avoid multiple painful movements of the skier to raise or lower the heels. The slope will be measured continuously and the comfort of the skier improved. The project involves choosing an actuating mechanism and integrating it in a binding prototype. In addition, the development of the electronics including microcontroller, accelerometer and drive will have to be designed. Finally, a strategy will be set to control the prototype in working conditions.

2011

Chargement

Mobile Objects as Mobile Processes

Massimo Merro

Obliq is a lexically-scoped, distributed, object-based programming language. In Obliq, the migration of an object is proposed as creating a clone of the object at the target site, whereafter the original object is turned into an alias for the clone. Obliq has only an informal semantics, so there is no proof that this style of migration is safe i.e., transparent to object clients In previous work, we introduced Ojeblik, an abstraction of~Obliq, where, by lexical scoping sites have been abstracted away. We used Ojeblik in order to exhibit how the semantics behind Obliq's implementation renders migration unsafe. We also suggested a modified semantics that we conjectured instead to be safe. In this paper, we rewrite our modified semantics of \OBLIQ\ in terms of the pi-calculus, and we use it to formally prove the correctness of object surrogation, the abstraction of object migration in Ojeblik

2002

Chargement

Message-based concurrency using actors has the potential to scale from multicore processors to distributed systems. However, several challenges remain until actor-based programming can be applied on a large scale. First, actor implementations must be efficient and highly scalable to meet the demands of large-scale distributed applications. Existing implementations for mainstream platforms achieve high performance and scalability only at the cost of flexibility and ease of use: the control inversion introduced by event-driven designs and the absence of fine-grained message filtering complicate the logic of application programs. Second, common requirements pertaining to performance and interoperability make programs prone to concurrency bugs: reusing code that relies on lower-level synchronization primitives may introduce livelocks; passing mutable messages by reference may lead to data races. This thesis describes the design and implementation of Scala Actors. Our system offers the efficiency and scalability required by large-scale production systems, in some cases exceeding the performance of state-of-the-art JVM-based actor implementations. At the same time, the programming model (a) avoids the control inversion of event-driven designs, and (b) supports a flexible message reception operation. Thereby, we provide experimental evidence that Erlang-style actors can be implemented on mainstream platforms with only a modest overhead compared to simpler actor abstractions based on inversion of control. A novel integration of event-based and thread-based models of concurrency enables a safe reuse of lock-based code from inside actors. Finally, we introduce a new type-based approach to actor isolation which avoids data races using unique object references. Simple, static capabilities are used to enforce a flexible notion of uniqueness and at-most-once consumption of unique references. Our main point of innovation is a novel way to support internal aliasing of unique references which leads to a surprisingly simple type system, for which we provide a complete soundness proof. Using an implementation as a plug-in for the EPFL Scala compiler, we show that the type system can be integrated into full-featured languages. Practical experience with collection classes and actor-based concurrent programs suggests that the system allows type checking real-world Scala code with only few changes.

EPFL2010

Chargement

EPFL2010