Temps de developpement d'un petit programme

Le
Fabien LE LEZ
Bonjour,

Il y a quelques jours, j'avais eu l'idée de programmer un petit moteur
de jeu de la vie pour tuer le temps. Projet qui n'a jamais vu le jour,
faute de temps à tuer ;-)

Mais je me demandais combien de temps, justement, il faut pour pondre
un tel programme.

Pour fixer les idées, on peut prendre un programme qui prend la
configuration initiale dans un fichier, et qui affiche les générations
l'une après l'autre jusqu'au Ctrl-C. Bien entendu, il doit fonctionner
quelles que soient les conditions (ou, au pire, afficher un message
d'erreur) -- comme un vrai programme, quoi :-)

En gros, combien de temps mettriez-vous pour faire ce genre de
programme simple ? Une heure ? Une journée ? Plus ? Moins ?


--
;-)
  • Partager ce contenu :
Vos réponses
Trier par : date / pertinence
twxs
Le #240924
Fabien LE LEZ wrote:
Bonjour,

Il y a quelques jours, j'avais eu l'idée de programmer un petit moteur
de jeu de la vie pour tuer le temps. Projet qui n'a jamais vu le jour,
faute de temps à tuer ;-)
...
En gros, combien de temps mettriez-vous pour faire ce genre de
programme simple ? Une heure ? Une journée ? Plus ? Moins ?




c'est assez difficile d'evaluer le temps qu'on passe pour coder une
appli. Dans ce cas precis, je penche plus pour 1 heure. Enfin on est
jamais a l'abri d'un hic.
sinon, en general, qd on a les idées claires sur les algos, les classes
qu'on va mettre, etc... ca se passe plutot bien. Par contre quand on
rentre dans le code de suite on peut partir dans des erreurs de
coneption qui font perdre un temps fou, soit parcequ'il faut tout
refaire, soit parcequ'il faut plus reflechir et bricoler pour que ca
fonctionne dans l'etat.

Twxs

Loïc Joly
Le #240866
Bonjour,

Il y a quelques jours, j'avais eu l'idée de programmer un petit moteur
de jeu de la vie pour tuer le temps. Projet qui n'a jamais vu le jour,
faute de temps à tuer ;-)

Mais je me demandais combien de temps, justement, il faut pour pondre
un tel programme.

Pour fixer les idées, on peut prendre un programme qui prend la
configuration initiale dans un fichier, et qui affiche les générations
l'une après l'autre jusqu'au Ctrl-C. Bien entendu, il doit fonctionner
quelles que soient les conditions (ou, au pire, afficher un message
d'erreur) -- comme un vrai programme, quoi :-)

En gros, combien de temps mettriez-vous pour faire ce genre de
programme simple ? Une heure ? Une journée ? Plus ? Moins ?


Le moteur de jeu me semble rapide ici. A mon avis, le temps dépend
principalement :
- De à quel point on souhaite faire ça de manière générique
- De quelle manière et avec quels outils initiaux on veut réaliser
l'affichage
- De la robustesse du format d'entrée

En fonction des limites raisonnables de ces critères, je dirais entre 1h
et 3j...

--
Loïc

tibug
Le #240863
Bonjour,


Bonjour,

Il y a quelques jours, j'avais eu l'idée de programmer un petit moteur
de jeu de la vie pour tuer le temps. Projet qui n'a jamais vu le jour,
faute de temps à tuer ;-)

Mais je me demandais combien de temps, justement, il faut pour pondre
un tel programme.

Pour fixer les idées, on peut prendre un programme qui prend la
configuration initiale dans un fichier, et qui affiche les générations
l'une après l'autre jusqu'au Ctrl-C. Bien entendu, il doit fonctionner
quelles que soient les conditions (ou, au pire, afficher un message
d'erreur) -- comme un vrai programme, quoi :-)

En gros, combien de temps mettriez-vous pour faire ce genre de
programme simple ? Une heure ? Une journée ? Plus ? Moins ?


si ton intention est de te focaliser sur la création du moteur à
proprement parler, ce qui suit ne s'applique sans doute pas

pour tuer le temps tout en t'amusant en créant des programmes dans
le syle "jeu de la vie" ou plus généralement faire de la simulation de
systèmes multi-agents tu devrais peut-être jetter un oeil sur une
bibliothèque/plateforme nommée ARéVi : http://www.enib.fr/~harrouet/

je ne l'ai jamais utilisé mais on doit pouvoir réaliser assez rapidement
des chose sympas

<hs>
dans le cadre d'un cours sur les SMA et systèmes réactifs, on utilisait
le language oRis ("pré-ARéVi") qui est interprété avec une syntaxe qui
emprunte un peu au C++ et à Java. On y trouve aussi les
fonctionnalités de simulation SMA et rendu 3D (limité)

le premier tp consistait à mettre en concurence des loups et des moutons
(bon ok, des cercles noirs et blancs ;-), le projet consitait ensuite à
mettre en concurence des équipes de robots dans un labyrinthe 3D texturé
avec éditeur de mondes, radars, poursuite caméra... (là plusieurs jours)
bref interlude supra-ludique entre initiation à Mathematica et
découverte du lambda-calcul :))

si j'avais aussi un peu de temps à tuer je me remettrai bien à donner
encore quelques moutons en pâture :(
</hs>

A+

tibug

Jean-Marc Bourguet
Le #240795
Fabien LE LEZ
Bonjour,

Il y a quelques jours, j'avais eu l'idée de programmer un petit moteur
de jeu de la vie pour tuer le temps. Projet qui n'a jamais vu le jour,
faute de temps à tuer ;-)

Mais je me demandais combien de temps, justement, il faut pour pondre
un tel programme.

Pour fixer les idées, on peut prendre un programme qui prend la
configuration initiale dans un fichier, et qui affiche les générations
l'une après l'autre jusqu'au Ctrl-C. Bien entendu, il doit fonctionner
quelles que soient les conditions (ou, au pire, afficher un message
d'erreur) -- comme un vrai programme, quoi :-)

En gros, combien de temps mettriez-vous pour faire ce genre de
programme simple ? Une heure ? Une journée ? Plus ? Moins ?


Que faut-il?

Pour le moteur: une classe pour le tableau, simple conteneur
mais qui implémente le choix du comportement aux frontières
(frontière de cellules vides, fontière de cellule pleines --
deux choses implémentables par sentinelles --, tore, ...),
simple wrapper autour de std::vector<std::vector<char> >.

On va faire du double buffering (deux tableaux, on calcule
le nouvel état dans un à partir de celui dans l'autre).
Donc une fonction next qui a les deux tableau en argument.
Plus 4 variables globales indiquant la variante du jeux
(pour une case vide, apparition d'une cellule si on se
trouve entre les deux premières, pour une case pleine
maintient si on se trouve entre les deux autres). Simple
double boucle utilisant une fonction comptant le nombre de
voisins.

OK. Pour les sorties, simple affichage du tableau (supposé
contenir des '*' et des ' ', c'est pour ça que c'est un
tableau de char) précédé d'une ligne blanche (ou si on veut
faire plus sioux, code ECMA-48 d'effacement et retour en
haut à gauche). Ce serait à peine plus compliqué d'utiliser
le mode tektronix des xterm si je me souvenais des codes à
utiliser. Ou même de faire qqch pour Xlib directement si on
accepte que je reprenne le framework d'un programme
dessinant des ensembles de Mandelbrot.

Pour les entrées, c'est le plus compliqué (comme souvent).
Tout dépend du format choisi et de la qualité des messages
d'erreur. Le très simpliste (4 nombres donnant le les 4
bornes évoquées ci-dessus suivit de lignes n'ayant que des
'*' et des ' ', message d'erreur unique: "bad format" si
quoi que ce soit se passe mal) peut être très vite fait.

Ce doit être faisable en moins de 2 heures. Il m'avait
fallu environ 2 heures pour faire un puissance 4 suite à la
lecture de
http://citeseer.ist.psu.edu/aronsson95comparison.html (mais
là il y avait un peu plus d'algorithmique puisqu'il y a un
alpha-beta). Je trouvais leurs 18 heures complètement
farfelues. Il m'avait fallu aussi moins de 600 lignes mais
je ne sais plus combien.

A+

--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org

kanze
Le #240791
Jean-Marc Bourguet wrote:
Fabien LE LEZ
Il y a quelques jours, j'avais eu l'idée de programmer un
petit moteur de jeu de la vie pour tuer le temps. Projet qui
n'a jamais vu le jour, faute de temps à tuer ;-)

Mais je me demandais combien de temps, justement, il faut
pour pondre un tel programme.

Pour fixer les idées, on peut prendre un programme qui prend
la configuration initiale dans un fichier, et qui affiche
les générations l'une après l'autre jusqu'au Ctrl-C. Bien
entendu, il doit fonctionner quelles que soient les
conditions (ou, au pire, afficher un message d'erreur) --
comme un vrai programme, quoi :-)

En gros, combien de temps mettriez-vous pour faire ce genre
de programme simple ? Une heure ? Une journée ? Plus ? Moins
?


Que faut-il?


[...]

Ce doit être faisable en moins de 2 heures.


Nettement, si on sait exactement ce qu'il faut implémenter. En
fait, dans ce genre de problème, souvent ce qui prend le plus de
temps, c'est la spécification. Tu as cité les entrées, par
exemple : typiquement, spécifier le format d'entrée va prendre
plus de temps que de le programmer (et gérer les erreurs plus de
temps que traiter les entrées correctes). Et a priori, pour
quelque chose d'aussi simple, les entrées vont prendre 80% du
temps de programmation.

Je trouve que prèsque toujours, une fois qu'on sait exactement
ce qu'il y a à faire, le codage va très vite. Et que quand le
codage n'est pas simplement mechanique, et exige de la
reflexion, c'est qu'on n'a pas assez bien spécifier le problème.

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


Poster une réponse
Anonyme