Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

exercice de style: Single Class Object Model

2 réponses
Avatar
micha
Single Class Object Model: ceci est un exercice de style minimaliste
et constructiviste consistant =E0 concevoir un Mod=E8le Objet autour d'une
seule et unique classe. Le but est qu'elle soit le plus agnostique
possible (le moins d'hypoyth=E8ses possible sur la fa=E7on dont elle sera
utilis=E9e), tout en restant utilisable et apte =E0 impl=E9menter des
applications de complexit=E9 arbitraire (c'est l'intention tout du
moins...).
Le principe de base consiste:

- D'une part =E0 reproduire un r=E9seau s=E9mantique sous forme de triplets=
,
comme dans le langage RDF ("The underlying structure of any expression
in RDF is a collection of triples, each consisting of a subject, a
predicate and an object")
- D'autre part =E0 s'inspirer de la programmation fonctionnelle, le
langage LISP en particulier, dans lequel toute entit=E9 peux =EAtre
=E9valu=E9e et retourner un r=E9sultat (du simple entier =E0 l'algorithme).
Dans l'API (!!) il suffit donc d'une seule m=E9thode: 'evaluate', qui
devra bien s=FBr =EAtre red=E9finie dans des classes d=E9riv=E9es pour en
impl=E9menter une application (Attention !! les classes d=E9riv=E9es ne
doivent ajouter pas de m=E9thodes =E0 l'API constitu=E9e par la classe
unique du mod=E8le objet, sinon le paradigme de 'Single Class Object
Model' est d=E9truit)

NB: J'ai commenc=E9 l'impl=E9mentation d'un prototype d'interpr=E9teur Lisp
comme 'Proof Of Concept"

Sur GitHub: https://github.com/terimakasi/scom

2 réponses

Avatar
Yliur
Le Thu, 17 May 2012 17:06:08 -0700 (PDT)
micha a écrit :

Single Class Object Model: ceci est un exercice de style minimaliste
et constructiviste consistant à concevoir un Modèle Objet autour d'une
seule et unique classe. Le but est qu'elle soit le plus agnostique
possible (le moins d'hypoythèses possible sur la façon dont elle sera
utilisée), tout en restant utilisable et apte à implémenter des
applications de complexité arbitraire (c'est l'intention tout du
moins...).
Le principe de base consiste:

- D'une part à reproduire un réseau sémantique sous forme de triplets,
comme dans le langage RDF ("The underlying structure of any expression
in RDF is a collection of triples, each consisting of a subject, a
predicate and an object")
- D'autre part à s'inspirer de la programmation fonctionnelle, le
langage LISP en particulier, dans lequel toute entité peux être
évaluée et retourner un résultat (du simple entier à l'algorithme).
Dans l'API (!!) il suffit donc d'une seule méthode: 'evaluate', qui
devra bien sûr être redéfinie dans des classes dérivées pour en
implémenter une application (Attention !! les classes dérivées ne
doivent ajouter pas de méthodes à l'API constituée par la classe
unique du modèle objet, sinon le paradigme de 'Single Class Object
Model' est détruit)

NB: J'ai commencé l'implémentation d'un prototype d'interpréteur Lisp
comme 'Proof Of Concept"

Sur GitHub: https://github.com/terimakasi/scom



Oui, autant écrire directement l'interpréteur Lisp.

Il y a un objectif particulier ?

Si le but est d'avoir quelque chose comme Lisp sur une JVM, il y a par
exemple ABCL, une implémentation de Common Lisp pour la JVM.
Avatar
micha
On 20 mai, 22:21, Yliur wrote:
Le Thu, 17 May 2012 17:06:08 -0700 (PDT)
micha a écrit :









> Single Class Object Model: ceci est un exercice de style minimaliste
> et constructiviste consistant à concevoir un Modèle Objet autour d' une
> seule et unique classe. Le but est qu'elle soit le plus agnostique
> possible (le moins d'hypoythèses possible sur la façon dont elle se ra
> utilisée), tout en restant utilisable et apte à implémenter des
> applications de complexité arbitraire (c'est l'intention tout du
> moins...).
> Le principe de base consiste:

> - D'une part à reproduire un réseau sémantique sous forme de trip lets,
> comme dans le langage RDF ("The underlying structure of any expression
> in RDF is a collection of triples, each consisting of a subject, a
> predicate and an object")
> - D'autre part à s'inspirer de la programmation fonctionnelle, le
> langage LISP en particulier, dans lequel toute entité peux être
> évaluée et retourner un résultat (du simple entier à l'algorith me).
> Dans l'API (!!) il suffit donc d'une seule méthode: 'evaluate', qui
> devra bien sûr être redéfinie dans des classes dérivées pour en
> implémenter une application (Attention !! les classes dérivées ne
> doivent ajouter pas de méthodes à l'API constituée par la classe
> unique du modèle objet, sinon le paradigme de 'Single Class Object
> Model' est détruit)

> NB: J'ai commencé l'implémentation d'un prototype d'interpréteur Lisp
> comme 'Proof Of Concept"

> Sur GitHub:https://github.com/terimakasi/scom" target="_blank" class="text-blue hover:opacity-90 " style="word-break: break-all;" rel="noopener nofollow">https://github.com/terimakasi/scom

Oui, autant écrire directement l'interpréteur Lisp.

Il y a un objectif particulier ?

Si le but est d'avoir quelque chose comme Lisp sur une JVM, il y a par
exemple ABCL, une implémentation de Common Lisp pour la JVM.


Merci pour votre réponse
Non le but n'est pas d'implémenter un interpréteur Lisp (c'est juste
un 'sample'). Le proket 'SCOM' (Single Class Object Model) est un
exercice constructiviste et minimaliste dont le but est d'illustrer
qu'il est possible de s'appuyer sur un Modèle Object/Framework
constitué d'une seule classe (cf. "It.java" sur https://github.com/terima kasi/scom)
afin de mettre en lumière que le 'réseau sémantique' des instances
(inspiré du RDF/SemWeb) est 'nécessaire et suffisant' pour développer
une application