Ummon a écrit 207 commentaires

Le problème du "gars qui a codé comme un porc" posera problème dans n'importe quel langage.

Par contre je te rejoins sur le coté dynamique qui peut entrainer des difficultés sur les moyens/gros projets.

[..]du faire des merges,[..]
Tu fais des 'merges' à la main ? Utilises-tu un gestionnaire de versions ? (git, mercurial, etc..)

[..]relire du code[..]
N'est-ce justement pas une des forces de Python que d'être concis et lisible ?

[..]mais dès qu'il y a de l'édition concurrente, ça fout la zone lors des merges,[..]
Évidemment, la répartition du type "toi tu t'occupe des if et moi des for" n'est pas forcément la bonne approche.

[..]lorsq'une fonction/classe dépasse la hauteur de l'écran rien ne va plus.
Ton éditeur doit certainement avoir un bidule sur la droite que l'on appelle vulgairement "ascenseur".

J'ai également un petit projet[1] de logiciel P2P en cours de réalisation à la différence qu'il ne fonctionne uniquement sur un LAN. Le logiciel se veut également assez minimaliste.

Le protocole est décrit[2] sur le wiki[3], ça peut éventuellement te donner quelques idées.

Le fait de restreinte un réseau à une liste d'amis de confiance s'appelle du F2F[4] (friend-to-friend), plusieurs logiciels existent déjà, comme par exemple OneSworm[5] ou AllianceP2P[6], ça peut également te donner des idées.

[1] : http://dev.euphorik.ch/projects/show/pmp
[2] : http://dev.euphorik.ch/wiki/pmp/Protocol_core-core
[3] : http://dev.euphorik.ch/wiki/pmp
[4] : http://en.wikipedia.org/wiki/Friend_to_friend
[5] : http://oneswarm.cs.washington.edu/
[6] : http://www.alliancep2p.com/

Elle se trouve également sur dailymotion en deux parties : http://www.pcinpact.com/actu/news/54465-seguela-lefebvre-bay(...)

Peut-être qu'un jour on pourra corriger le contenu des journaux... (mais ouais ! Moinssez-moi !! rien a fout' la lutte continue !!)

Dans le pire des cas il est toujours possible de faire un tunnel en passant par le port 443 du proxy HTTP (ce que je fais en ce moment).
Je ne sais pas si c'est facilement détectable, je pense que non...

Une chausette TCP est bidirectionnelle.

[..]qui consiste à mélanger la syntaxe et la sémantique.

La syntaxe définit la sémantique. Tu peux aussi dire "oui mais on m'oblige à utilise des accolades pour la définition de mes blocs, bouh!" bein ouais, derrière l'accolade il y a une sémantique, on aurait pu aussi choisir des begin / end.

Personnellement je trouve cela pas trop mal, ça parait restreindre les libertés à première vue mais ça rend le code plus lisible... un peu comme l'indentation en Python.

J'avais fait un truc similaire mais en Erlang pour la partie serveur. Couplé à la base de données Mnesia cela permet d'écouter les évènements de la base, insertion ou suppression de tuples par exemple et de reporter les évènements directement au client (navigateur).

Le bousin (adresse de preprod pour faire n'importe quoi) : http://www.euphorik.ch:8090
Le code : http://dev.euphorik.ch/repositories/browse/euk/tags/1.1.6

T'es sur ? http://www.clubic.com/actualite-309786-video-fans-envahissen(...)

Petite redirection spéciale[1] dans le cas où l'hôte contient '.culture.fr'[2].

[1] : http://www.jaimelesartistes.info/block.php
[2] : http://pastebin.com/f6a8a89de

Ma réponse précédente, un peu provocatrice, faisait référence aux langages traditionnels.

* En Haskell, les variables se rapproche plus de constantes Java/C++ dans la mesure ou elle ne peuvent pas muter, un "a += 2" n'a aucun sens.

* Le terme 'objet' est très large, là encore je faisais référence aux classes à la Java/C++ qui définisse un état interne et une série d'opérations liées à ces données. C'est surtout la notion d'identité qui s'oppose à celle de valeur.

* Concernant les effets de bords, la garantit de transparence référentielle pour le fonctions pures est un avantage. Évidemment il est possible de dégénérer vers le passage systématique de tout l'état du système via une "state monade" ;)

* Pour la généricité, elle est au coeur du système de type. Mais c'est vrai qu'il faudra toujours un effort supplémentaire pour généraliser du code.

Voici un guide pour comprendre les monades en douceur : http://www.haskell.org/all_about_monads/html/index.html

Certes, Haskell est très différent des autres langages et certes il faut un certain investissement initial pour s'y plonger, mais je ne crois pas qu'il soit, au final, plus compliqué qu'un autre langage. Au contraire, le but final et de pouvoir exprimer beaucoup plus en écrivant moins.

Pour moi un langage idéal c'est un langage qui (en vrac) :
- N'a pas de boucle (trop primitif)
- Pas de variable (trop variable :F)
- Pas de notion d'objet (trop restrictif)
- Essaie de réduire au maximum les effets de bord
- Permet de créer facilement des modules génériques et réutilisables
- Statiquement typé via inférence de type
- Compilable en code machine ou pour une machine virtuelle pour avoir des perfs décentes
- Exécutable comme un script sans passé par une phase de compilation comme perl/python/ruby et cie
- Possédant une plateforme de distribution d'applications et de libs

... ah mais il existe en fait mon langage idéal : http://haskell.org/

---> []

Ils auraient dû choisir Redmine[1] et en profiter pour l'améliorer, sniff...

[1] : http://www.redmine.org

Une petite macro parmi plein d'autres dans le code sur lequel je bosse :


#define UOL_IMPLEMENT_FIND_INFO_CLASS(class_name,base_class) \
UOL_IMPLEMENT_SERIAL( class_name##FindInfo, base_class##FindInfo, \
UOL_RUNTIME_CLASS(class_name)->GetSchema() | VERSIONABLE_SUBSCHEMA ) \
class_name##FindInfo::class_name##FindInfo( class_name##Properties *pOriginal ) \
: m_pOriginal( pOriginal ) { if( m_pOriginal ) m_pOriginal->AddRef() ; } \
void class_name##FindInfo::OnCreate( UINT uFlags ) \
{ base_class##FindInfo::OnCreate( uFlags ) ; \
if( GetRuntimeClass() == UOL_RUNTIME_CLASS( class_name##FindInfo ) ) { \
ASSERT( !m_pProperties ) ; \
m_pProperties = new class_name##Properties ; \
m_pProperties->Initialize( this, m_pOriginal ) ; \
m_pProperties->OnCreate( uFlags ) ; UOL_ASSERT_VALID( m_pProperties ) ; \
m_pProperties->AddRef() ; \
if( m_pOriginal ) { SetClass( m_pOriginal->GetOwner()->GetRuntimeClass() ) ; \
CUOLGUID *pGUID = dynamic_cast<CUOLGUID *>( m_pOriginal->GetOwner() ) ; \
UOL_ASSERT_VALID( pGUID ) ; SetGUID( &pGUID->GetGUID() ) ; } \
else SetClass( UOL_RUNTIME_CLASS( class_name ) ) ; \
if( m_pOriginal ) m_pOriginal->ReleaseRef() ; } } \
__UOL_IMPLEMENT_GET_PROPERTIES(class_name##FindInfo,class_name##Properties) \
__UOL_IMPLEMENT_DIAGNOSTICS_FIND_INFO(class_name,base_class)



Je ne connaissais pas.

Mes buts sont multiples :
* Réaliser un logiciel libre :)
* Réaliser un projet de A à Z
* Essayer de rassembler une équipe
* Répondre exactement à mes besoins

Je pense que réaliser un logiciel de partage pour LAN uniquement entraine quelques choix spécifiques comme par exemple l'utilisation de multicast, la taille des chunks relativement élevée (unité de partage), le "full-trusting" (pas d'authentification), pas besoin de chiffrage, etc..

Effectivement, comme je l'ai dit, ce nom n'est pas forcément définitif. C'est pas pire que Ubuntu ;)

En fait, Aybabtu signifie 'All you bytes are belong to us' :P

J'avais pensé à 'Pumpage' au début : http://dev.euphorik.ch/wiki/pmp/Logo
(d'ailleurs je préfère toujours à Aybabtu, mais des voix se sont élevées contre moi).

Je m'écris une note pour plus tard concernant Jabber/Bonjour :).

Justement, je ne veux pas une usine à tout faire, je veux réaliser un logiciel qui fait une tâche et qui la fait bien.

De plus j'aimerai faire les choses suivantes :
- Calculer les 'hashes' des parties composant un fichier et les échanger entre clients ;
- Transmettre qu'une partie de fichier, en gros pouvoir acquérir un fichier à partir de plusieurs hôtes en même temps ;
- Réaliser une recherche sur un ensemble de clients simultanément (actuellement j'utilise du multicast UDP).

Plus d'informations ici (c'est pas forcément très bien décrit, mais c'est un début) : http://dev.euphorik.ch/wiki/pmp/Protocol_core-core

Est-ce que XMPP/WebDAV me permet de réaliser tout ça ? (Je pose cette question de manière naïve, sans connaitre ces protocoles).

C'est vrai que c'est une approche logique de réutiliser de l'existant et de ne pas réinventer la roue.
Néanmoins cette approche n'est pas forcément la meilleure dans tous les cas car elle peut engendrer :
- Plus de dépendance envers des libs/protocoles ;
- De la gestion des versions de celles-ci, intégration dans le processus de build ;
- Des connaissances à acquérir envers celles-ci (et pas des moindre vue l'étendue de certaine) ;
- Des limitations inhérentes liées au fonctionnement de celles-ci. Difficile d'effectuer des modifs pour coller exactement aux besoins ;
- Un 'overhead' à l'exécution ;
- Plus de couches et donc augmentation de la complexité globale.

Pour l'instant la seul lib que j'utilise (mis à par Qt) est Protocol Buffer[1] permettant la définition des messages ainsi que leur sérialisation.

Quels seraient les avantages concrets, dans mon cas, d'utiliser XMPP ?

[1] : http://code.google.com/p/protobuf/

PS: je veux éviter si possible d'utiliser du XML ;)

Oui...
Si vous voulez vraiment un vrai langage un peu innovateur (au niveau programmation concurrente notamment) qui tourne sur la JVM il faut plutôt regarder du coté de Clojure[1] ou éventuellement Scala[2]. Je vous recommande les présentations vidéos[3] de Clojure par Rich Hickey, son auteur.

[1] : http://www.clojure.org
[2] : http://www.scala-lang.org/
[3] : http://clojure.blip.tv/

Boh, l'un n'empêche pas l'autre, culture générale, toussa (dans la mesure ou Hyper fort est un peu exagéré pour réaliser un petit site web de type vitrine)

Je rajouterai une couche de troll en citant Poelvoorde :
Tu ne te permets rien du tout, tu vas me soigner cette vilaine peau et puis tu te permettras. à propos de ce magnifique site : http://isaacproject.u-strasbg.fr/


---» []

'Micro noyau' ne veut pas dire plus léger (en terme d'empreinte mémoire mais également en nombre de ligne de code) ni plus rapide mais prône plutôt la robustesse et la sécurité.

Je pense que ce qui manque à Linux c'est un peu de 'refactoring', nettoyage et documentation ... ce que les gens ont toujours de la peine à faire ;). Un logiciel qui ne passe pas de temps-en-temps par ces phases est condamné.