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 ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
twxs
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
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.
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
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
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...
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
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
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>
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
Fabien LE LEZ writes:
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
Fabien LE LEZ <gramster@gramster.com> writes:
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
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
Jean-Marc Bourguet wrote:
Fabien LE LEZ writes:
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
Jean-Marc Bourguet wrote:
Fabien LE LEZ <gramster@gramster.com> writes:
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
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
