Suite

GDAL_CALC fonctionne mais j'obtiens une erreur python à la fin de chaque processus qui empêche l'automatisation


Python 3.4.1, GDAL 1.11.0, OSGEO4W, Windows 7, OSGEO4W Windows Shell

Tout 64 bits

(ArcGIS est également installé 10.2 avec Python 2.7)

Donc gdal_translate fonctionne bien.

gdal_calc fournit des sorties parfaites mais à la fin de chaque processus, j'obtiens l'erreur ci-dessous. C'est un problème car je ne peux rien automatiser en raison de cette erreur contextuelle. J'ai cliqué sur Fermer et l'erreur disparaît, le fichier de sortie est parfait à 100% mais la prochaine ligne gdal_calc me donne la même erreur.

Ceci est un exemple de ligne de code qui donne l'erreur (presque toutes mes commandes gdal_calc donnent l'erreur mais pas gdal_translate).

gdal_calc.py -A 2000025-2000032.s0481pfv50-sst-16b.hdf.tiff_C.tiff -BC:	empQUAL2000025-2000032.m0481pfv50-qual.hdf.tiffBINARY.tiff --outfile=A25_32_SSTQUAL4.tiff -- calc="A*B"

et c'est l'erreur. Comme je l'ai dit, le processus fonctionne réellement et continuera lorsque je fermerai la boîte d'erreur. Une fois que le mot DONE apparaît, l'erreur apparaît, je ferme la fenêtre, puis la ligne de code suivante s'exécute, puis l'erreur apparaît à nouveau et ainsi de suite.

Message d'erreur supplémentaire généré > Signature du problème : Nom de l'événement du problème : APPCRASH Nom de l'application : python.EXE Version de l'application : 0.0.0.0 Horodatage de l'application : 5193f3af Nom du module d'erreur : ntdll.dll Version du module d'erreur : 6.1.7601.18247 Horodatage du module d'erreur : 521eaf24 Code d'exception : c0000005 Exception Offset : 0000000000053290 OS Version : 6.1.7601.2.1.0.256.48 Locale ID : 1033 Informations supplémentaires 1 : 8c64 Informations supplémentaires 2 : 8c64dfac0942d27b36722f7434c64847 Informations supplémentaires 3 : e156 Informations supplémentaires 4 : e156d5603c95b65c33088aa70929b4be

En tant que extrêmement approche brutale et de dernier recours à cela, vous pouvez désactiver les boîtes de dialogue de plantage dans Windows en utilisant leDontShowUIvaleur dans les clés de registre de rapport d'erreurs Windows.


J'ai la même erreur de la fenêtre OSGEO4W… Il se peut que ce soit un problème avec la configuration de l'environnement, quelque chose à propos d'une bibliothèque manquante lorsque j'y plonge :

from _sre import MAXREPEAT ImportError : impossible d'importer le nom MAXREPEAT

Cependant, dans une fenêtre de commande normale, cela fonctionne très bien… J'ai ajouté GDAL_DATA et d'autres variables d'environnement qui sont importantes pour que GDAL fonctionne en python et j'utilise python 2.7 (fourni avec ArcMap).

Variables d'environnements utilisées par GDAL :

GDAL_DATA C:Program FilesQGIS Dufoursharegdal GDAL_DRIVER_PATH C:Program FilesQGIS Dufouringdalplugins GEOTIFF_CSV C:Program FilesQGIS Dufourshareepsg_csv PROJ_LIB C:Program FilesQGIS Dufourshare proj

Vous devrez trouver ces dossiers dans votre système local, ils devraient être assez proches.

Pour automatiser enregistrez votre liste de commandes python avec l'extension ".bat" et double-cliquez. Si vous n'êtes pas à l'aise avec la définition permanente de vos variables d'environnement, utilisez un format comme celui-ci :

set GDAL_DATA=C:Program FilesQGIS Dufoursharegdal set GDAL_DRIVER_PATH=C:Program FilesQGIS Dufouringdalplugins set GEOTIFF_CSV=C:Program FilesQGIS Dufourshareepsg_csv set PROJ_LIB=C : Program FilesQGIS Dufourshareproj gdal_calc.py -A 2000025-2000032.s0481pfv50-sst-16b.hdf.tiff_C.tiff -BC:	empQUAL2000025-2000032.m0481pfv50-qual.hdf.tiffBINARY. tiff --outfile=A25_32_SSTQUAL4.tiff --calc="A*B" pause

Lorsqu'il est enregistré en tant que fichier batch (.bat) et double-cliqué, il ouvrira une fenêtre de commande, exécutera la commande, puis invitera l'utilisateur à appuyer sur Entrée pour continuer (sortir). Les paramètres d'environnement ne sont pas permanents lorsqu'ils sont effectués de cette manière et ne s'appliquent qu'à cette fenêtre. Si vous êtes préoccupé par la version de python qui exécute le code, utilisezdéfinir le chemin =;%chemin%pour limiter le chemin à une seule version.

Dans un fichier batch, %A est remplacé par %%A, le processeur de commandes supprime le premier % :

set GDAL_DATA=C:Program FilesQGIS Valmierasharegdal set GDAL_DRIVER_PATH=C:Program FilesQGIS Valmieraingdalplugins set GEOTIFF_CSV=C:Program FilesQGIS Valmierashareepsg_csv set PROJ_LIB=C : Program FilesQGIS Valmierashareproj pause pour %%A dans ("C:	emp*.hdf") do gdal_translate -of GTiff -a_srs "+init=epsg:4326" -a_ullr -180 90 180 - 90 -co "COMPRESS=PACKBITS" -sds "%%A" "%%A.tiff" pour %%A dans ("C:	emp*.tiff") do gdalinfo "%%A" >>"% %A.txt" pour %%A dans ("C:	emp*.tiff") do gdal_calc.py -A "%%A" --outfile="%%ABINARY.tiff" --calc="0 *(A<3)" --calc="1*(A>3)" pour %%A dans ("C:	emp*.tiff") do gdal_calc.py -A "%%A" -- outfile="%%A_C.tiff" --calc="A*(0.07500000298)" gdal_calc.py -A 2000001-2000008.s0481pfv50-sst-16b.hdf.tiff_C.tiff -BC:	emp2000001-2000008. m0481pfv50-qual.hdf.tiffBINARY.tiff --outfile=A1_8_SSTQUAL4.tiff --calc="A*B" gdal_calc.py -A 2000009-2000016.s0481pfv50-sst-16b.hdf.tiff_C.tiff -BC:	emp 20000009-2000016.m0481pfv50-qual.hdf.tiffBINARY.tiff --outfile=A9_16_SS TQUAL4.tiff --calc="A*B" gdal_calc.py -A 2000017-2000024.s0481pfv50-sst-16b.hdf.tiff_C.tiff -BC:	emp2000017-2000024.m0481pfv50-qual.hdf.tiffBINARY. tiff --outfile=A17_24_SSTQUAL4.tiff --calc="A*B" gdal_calc.py -A 2000025-2000032.s0481pfv50-sst-16b.hdf.tiff_C.tiff -BC:	emp2000025-2000032.m0481pfv50-qual .hdf.tiffBINARY.tiff --outfile=A25_32_SSTQUAL4.tiff --calc="A*B" gdal_calc.py -A A1_8_SSTQUAL4.tiff -B A9_16_SSTQUAL4.tiff -C A17_24_SSTQUAL4.tiff -D A25_4UM_C .tiff --calc="A+B+C+D" gdal_calc.py -A 2000001-2000008.m0481pfv50-qual.hdf.tiffBINARY.tiff -B 2000009-2000016.m0481pfv50-qual.hdf.tiffBINARY.tiff -C 2000017-2000024.m0481pfv50-qual.hdf.tiffBINARY.tiff -D 2000025-2000032.m0481pfv50-qual.hdf.tiffBINARY.tiff --outfile=QUAL_final.tiff --calc="A+B+C+D" gdal_calc. py -A SST_SUM_C.tiff -BC:	empQUAL_final.tiff --outfile=SST_Final_C.tiff --calc="A/B" gdal_translate SST_Final_C.tiff -of GTiff -ot Float32 -a_nodata 0 SST_Final_C_NoData.tiff gdal_fillnodata SST_Final_C_NoData.tiff -md 5 -si 2 SST_Final_C_NoData_Foc.tiff pour %%A dans ("C:	emplandmask*.hdf") do gdal_translate -of GTiff -a_srs "+init=epsg:4326" -a_nodata 2 - a_ullr -180 90 180 -90 -co "COMPRESS=PACKBITS" -sds "%%A" "%%A.tiff" pour %%A dans ("C:	emplandmask*.tiff") do gdal_calc. py -A "%%A" --outfile="%%A_FINAL.tiff" --calc="1*(A<5)" gdal_calc.py -A SST_Final_C_NoData_Foc.tiff -BC:	emplandmaskpfv50_land. m04.hdf.tiff_FINAL.tiff --outfile=SST.tiff --calc="A*B" gdal_translate SST.tiff -of GTiff -ot UInt16 -a_nodata 0 -stats -co "COMPRESS=LZW" SST_ALLDONE.tiff pause

Création de code à barres pdf417, disparité des mots de code de correction d'erreur Reed Solomon entre python et JAVA

J'ai créé un code-barres pdf417 en utilisant la bibliothèque Python pdf417gen.

Le code-barres était une représentation graphique de la chaîne "M1LONG". Le code-barres comporte deux colonnes de données et le niveau de sécurité de la correction d'erreur Reed Solomon est défini sur « 1 ». Cela indique qu'avec une entrée de huit mots de code de données, le nombre de mots de code de correction d'erreur doit être de quatre.

La sortie Python affiche les mots de code de données de D07 à D00 sous la forme <8, 389, 902, 11, 900, 344, 396, 900>. Le python répertorie les mots de code de correction d'erreurs de C03 à C00 sous la forme <718, 801, 313, 877>. Voici le Python qui a été utilisé pour générer tous les mots de code :

Les mots de code de correction d'erreurs sont générés à l'aide de polynômes, d'arithmétique du champ de Galois et de compléments de module 929, qui est le nombre de mots de code possibles pour le système pdf417. Les calculs utilisent un certain nombre de facteurs pour simplifier le processus. Pour le niveau de sécurité 1, le nombre recommandé de facteurs est de quatre. Les facteurs sont 522 568 723 809

Le problème est le suivant. J'ai essayé de recréer les mots de passe d'erreur en utilisant un pseudo code JAVA obtenu à partir de http://grandzebu.net/informatique/codbar-en/pdf417.htm

J'ai écrit un programme JAVA pour essayer de générer les mêmes mots de code que le logiciel Python décrit ci-dessus, mais il ne génère pas les mêmes mots de code d'erreur.

Le programme JAVA se compile et s'exécute, le calcul semble correct à mon œil non averti, mais les codes d'erreur produits ne sont pas les mêmes. Voici mon JAVA, Les variables JAVA sont appelées de la même manière que Python pour faciliter la comparaison des deux programmes.

Je serais très reconnaissant de savoir quel est le problème avec le code JAVA qui l'empêche de générer les mêmes mots de code d'erreur que le programme python contenu dans la bibliothèque pdf417gen.


La bibliothèque TikZ 2.10, externe, résout ce problème. L'externalisation de tous les graphiques TikZ dans un document LaTeX est aussi simple que :

Si votre document s'appelle report.tex , cela va vider une série d'images : report-figure0.pdf , report-figure1.pdf , etc, etc. Pour obtenir une sortie plus gérable, vous pouvez spécifier un répertoire dans lequel le les fichiers sont à placer et les noms qui sont plus descriptifs que report-figure0.pdf :

Pour compiler le document, vous devrez vous assurer que le répertoire figures existe et exécuter pdflatex avec l'exécution du shell activée :

Un tas d'options est disponible pour personnaliser la façon dont les chiffres sont sortis. Voir la section 52.4 (cette numérotation est sujette à changement !) de la documentation de la version de développement pour des informations et des options complètes. Le manuel explique également comment obtenir une sortie EPS, mais cette option semble moins soignée que la sortie PDF.

Lorsque j'écrivais ma thèse de maîtrise, j'avais créé toutes mes figures et diagrammes avec tikz et pgfplots (en utilisant matplotlib2tikz). Les garder tous dans la source n'était pas acceptable, car la compilation devenait vraiment lente, donc je cherchais quelque chose qui me permettrait de compiler automatiquement tous ces chiffres dans des fichiers pdf que je pourrais inclure dans mon texte.

Pour diverses raisons, je n'étais entièrement satisfait d'aucune des autres solutions, j'ai donc écrit un script Python qui convenait à mon objectif.

Les choses que vous devez garder à l'esprit sont :

  1. Vous mettez le script au même niveau que votre fichier main.tex
  2. Vous écrivez votre code tikz. Vous placez chaque chiffre dans un fichier avec l'extension *.tikz. Chaque fichier ne contient que egin . finir .
  3. Vous écrivez le préambule que vous souhaitez utiliser avec les fichiers *.tikz. Cela ne contient pas nécessairement les mêmes packages que le préambule de votre fichier main.tex. La raison pour laquelle vous gardez un préambule commun pour toutes les figures est de faciliter la modification de choses comme les polices, etc.
  4. Vous exécutez le script !

Le script recherche récursivement dans une structure de dossiers les fichiers *.tikz et les compile à l'aide du préambule spécifié. Chaque fois que les scripts s'exécutent, il stocke l'heure de modification de chaque fichier *.tikz et lors des exécutions suivantes, il compile uniquement les fichiers nouvellement créés des fichiers qui ont été modifiés depuis la dernière exécution. Si vous apportez des modifications à votre préambule, vous passez simplement un argument de ligne de commande et il compile tous les fichiers *.tikz.

Sous linux ça marche très bien. Je ne l'ai pas testé sur Windows, mais je ne vois pas pourquoi il ne devrait pas fonctionner. Quoi qu'il en soit, même s'il y a un problème, le correctif sera vraiment trivial

Voici mon alternative La réponse de Konrad est probablement tout aussi bonne et certainement mieux documentée.

Je viens de trouver ce qui suit. Cela semble fonctionner assez bien (sur Unix/Linux et Mac) :

Une explication:

Il utilise grep pour filtrer toutes les lignes contenant eginpgfgraphicsnamed , mais, seulement s'il n'y a qu'un espace avant la commande dans la ligne. Cela évite que des commandes commentées soient également trouvées.

Ensuite, il appelle sed pour filtrer à partir de ces lignes uniquement la partie pertinente, c'est-à-dire l'argument de commande qui doit être utilisé comme nom de travail pdflatex. Il utilise ensuite for pour parcourir tous ces noms de travail et appelle pdflatex à tour de rôle pour chacun d'eux.

J'ai créé un script shell, qui crée des fichiers PDF à partir de tous mes tikz / pgfplots /. -Les figures. Par rapport aux solutions existantes, mon approche présente certains avantages : (Je ne connais pas très bien les solutions existantes., mais j'espère que certains des avantages sont de réels avantages.)

La construction des images individuelles ne se produit que si nécessaire, c'est-à-dire si la source ou les données incluses ou les en-têtes inclus sont plus récents que le PDF (existant ?). Si vous tracez, par ex. certaines données avec pgfplots, vous pouvez simplement mettre un nouveau fichier csv dans le bon dossier, et dans la prochaine compilation du document principal, cela est reconnu et seule l'image utilisant ce fichier est reconstruite.

Un autre avantage de ma solution est que les PDF sont compilés en parallèle. Mais vous êtes remarqué si un ou plusieurs fichiers PDF ne parviennent pas à compiler, y compris les informations détaillées des fichiers journaux, puis la compilation restante du document principal s'arrête. Le nombre de compilations exécutées en arrière-plan peut être limité à un nombre de processus comme 4 ou 8 (selon le nombre de cœurs de processeur que vous souhaitez utiliser). Ceci est particulièrement utile si un processus a besoin de beaucoup de RAM (dans mon cas, certaines images pgfplots étendues nécessitent > 1 Go de RAM lors de la compilation. )

L'option draft est reconnue pour éviter les compilations inutiles. En outre, il existe une option buildall et buildnone, qui peut être utile en cas de modification répétée des en-têtes.

Pas limité tikz , mais n'importe quel paquet devrait être possible, car chaque image n'est qu'un document .tex normal et complet.

Concernant tikz , j'ai eu quelques problèmes avec le texte coupé aux bords des images en utilisant standalone . Ce comportement ne se produit pas avec ma solution, car je recadre les pages A4 avec les images avec pdfcrop après la compilation.

J'ai un fichier .sty pour l'appel de script comme indiqué ci-dessous. Il existe une définition pour les images-Folder, deux exemples d'images et l'appel de script et la gestion des valeurs de retour. usepackage est la première ligne après documentclass dans mon document principal, il s'assure donc que tous les pdf sont toujours à jour.

L'image est incluse comme ceci dans un document principal (très court) :

Un exemple pour une image serait

Le script shell appelé est illustré ci-dessous. Il recherche dans chaque fichier .tex usepackage , input , pgfplotstableread et reconnaît également si les fichiers utilisés sont plus récents qu'un PDF éventuellement existant.


5 réponses 5

Vous devez toujours choisir les tests avec soin en ce qui concerne l'automatisation des tests. :)

L'une des raisons, comme vous l'avez dit, est le chevauchement (et avec cela, le temps d'exécution et la robustesse). Une Exemple clarifier:

  • Votre API a 10 points de terminaison qui peuvent renvoyer plusieurs messages d'erreur différents chacun.
  • Ne pas testez chaque erreur en tant que test d'interface utilisateur : cela prendra beaucoup de temps d'exécution et entraînera également la maintenance la plus élevée. Et oui, vous aurez un chevauchement fonctionnel avec l'API et les tests unitaires.
  • Ne pas tester chaque erreur en tant que test API si leur logique est entièrement couverte dans les tests unitaires.
  • Faire écrivez un test d'interface utilisateur pour une ou deux erreurs afin de vous assurer qu'elles sont correctement affichées par le front-end. Mais il s'agit probablement d'un système générique, donc si le système fonctionne, il fonctionnera pour tout message d'erreur. Les tests d'interface utilisateur doivent être considérés comme sonder les flux de l'application et voir qu'un utilisateur peut faire le travail, pas des tests approfondis de la logique.
  • Faire écrire des tests d'API pour une ou deux erreurs afin de s'assurer que l'intégration back-end fonctionne correctement de la demande à la réponse (au-delà de la portée des tests unitaires). Ou écrivez plus de tests pour des cas spécifiques (par exemple, où l'accès à la base de données entre en jeu, ce qui sera moqué dans un test unitaire).

Une autre raison de réfléchir aux cas à automatiser est simplement que tous les tests automatisés ne sont pas aussi utiles ou rentables à long terme. Je vous conseille de regarder sur YouTube la présentation d'Angie Jones sur "Quels tests devrions-nous automatiser" - voir également https://slides.com/angiejones/which-tests-should-we-automate#/20

Il n'y a pas de concept de chevauchement des cas de test dans différents niveaux de test,

Les deux sont complètement isolés

Juste parce que l'API fonctionne correctement, vous ne pouvez pas garantir que l'interface utilisateur fonctionne correctement.

Imaginez que tous vos tests d'API réussissent mais que l'utilisateur ne puisse pas utiliser l'interface utilisateur, imaginez que toute votre interface utilisateur fonctionne en raison des informations mises en cache mais que le backend réel échoue.

Assurez une couverture de bas niveau comme le test unitaire et le test d'API, cela garantit une exécution de test plus rapide et un retour d'information sur la construction. Cela garantira également un débogage plus rapide car vos tests seront davantage axés sur le composant ou la fonctionnalité.

Dans l'interface utilisateur, testez le flux commercial réel et les tests de gestion des erreurs

Dans chaque niveau de test, nous avons différentes portées de test.

Nous ne testons pas le flux commercial mais le composant et la fonctionnalité

Test d'intégration

Intégration avec d'autres composants, quelle est la stabilité du sous-système intégré pour pouvoir être utilisé pour s'étendre avec des composants de niveau supérieur. Comme l'API avec l'interface utilisateur

Test du système

Ici, vous testez l'utilisabilité, les interactions utilisateur, la régression visuelle, la logique métier et le flux.

Il n'y a donc pas de concept de chevauchement de tests dans différents niveaux de test

TLDR: vous aurez un chevauchement entre les cas de test d'intégration E2E et API, en termes de mêmes points de terminaison exercés dans les deux et c'est bon - cela vous aide à déterminer où est le problème si (. quand) quelque chose ne va pas.

Lorsque vous travaillez avec une base de code qui ne dispose pas actuellement de tests automatisés complets, commencer par les tests E2E(/functional/UI). Pourquoi?

L'automatisation de l'application via les flux de travail de l'interface utilisateur permet de créer de l'empathie pour les utilisateurs - à quoi servent-ils et comment le font-ils ?

Ces tests vous permettent de vérifier que le logiciel fournit réellement la valeur qu'il est censé pour vos utilisateurs, ne se soucient pas des appels ou des fonctions d'API ! Notez que ce serait différent si votre API était un produit en soi, pas seulement consommé par le client Web.

D'un point de vue plus technique, les tests de niveau inférieur nécessiteront probablement quelques modifications pour implémenter (par exemple, pour introduire des limites appropriées pour tester) le code écrit sans penser aux tests est souvent difficile à tester. Vous avez besoin des tests de niveau supérieur pour vous assurer que les modifications ont été effectuées correctement.

Cela conduira probablement à un endroit où vous aurez trop de tests E2E, caractérisés par des temps d'exécution de test trop longs, mais vous pouvez maintenant commencer à pousser les tests vers le bas de la pile vers l'intégration et les tests unitaires. Concentrez-vous sur le maintien d'un ensemble de flux de travail clés (cela peut être une bonne conversation avec les responsables du produit de votre équipe - tout le monde sait-il quels sont les flux de travail clés sommes?) au niveau E2E, puis pousser les chemins les moins importants et la répétition vers des tests de niveau inférieur.

En ce qui concerne les tests d'API en particulier, il y aura beaucoup de chevauchements. Vos cas de test E2E devraient exercer chaque point de terminaison au moins une fois (sinon, demandez-vous si les points de terminaison inutilisés peuvent être supprimés). Ce chevauchement est correct, car maintenant, si un test E2E échoue mais que les tests API pertinents réussissent, vous avez localisé le problème dans l'interface utilisateur. Mais il y aura des choses qui seront difficiles à tester via l'interface utilisateur. Ce sont généralement les chemins malheureux, par exemple:

vous avez probablement une validation des entrées au niveau de l'interface utilisateur qui empêche la demande d'être effectuée si elles ne sont pas valides, mais vous devriez toujours tester la validation côté serveur et

vous n'avez probablement pas de liens vers des ressources manquantes dans l'interface utilisateur, mais vous souhaitez tout de même tester les 404.

De même, il y a des choses qui sont difficiles à tester via l'API, et nécessitent beaucoup de configuration et de démontage dans ce cas, poussez plus loin pour tester unitaire la couche de logique de service/métier (je voudrais ne pas recommandent de tester à l'unité les couches contrôleur/transport ou référentiel/persistance, celles-ci ont tendance à être en grande partie passe-partout, s'ils ont beaucoup de logique, c'est probablement au mauvais endroit).


5 réponses 5

Avez-vous essayé d'utiliser le paramètre ConflictResolution:=xlLocalSessionChanges dans la méthode SaveAs ?

  • Ce paramètre ne permet à aucune macro de s'exécuter. Lorsque vous ouvrez un nouveau classeur Excel, vous n'êtes pas averti du fait qu'il contient des macros, vous ne savez donc peut-être pas que c'est la raison pour laquelle un classeur ne fonctionne pas comme prévu.

  • Ce paramètre empêche l'exécution des macros. Cependant, s'il y a des macros dans un classeur, une fenêtre contextuelle s'affiche pour vous avertir que les macros existent et ont été désactivées.

  • Ce paramètre autorise uniquement l'exécution des macros provenant de sources fiables. Toutes les autres macros ne s'exécutent pas. Lorsque vous ouvrez un nouveau classeur Excel, vous n'êtes pas averti du fait qu'il contient des macros, vous ne savez donc peut-être pas que c'est la raison pour laquelle un classeur ne fonctionne pas comme prévu.

  • Ce paramètre permet à toutes les macros de s'exécuter. Lorsque vous ouvrez un nouveau classeur Excel, vous n'êtes pas averti du fait qu'il contient des macros et peut ne pas être au courant des macros en cours d'exécution pendant que le fichier est ouvert.

Si vous faites confiance aux macros et que vous acceptez de les activer, sélectionnez cette option :

et cette boîte de dialogue ne devrait pas s'afficher pour les macros.

En ce qui concerne la boîte de dialogue d'enregistrement, après avoir noté que cela fonctionnait sur Excel pour Mac 2011, je suis tombé sur la question suivante sur SO, StackOverflow - Supprimer la boîte de dialogue lors de l'utilisation de VBA pour enregistrer une macro contenant un fichier Excel (.xlsm) en tant que non macro contenant le fichier (.xlsx). De là, la suppression de la boîte de dialogue ne semble pas possible, sauf éventuellement par une simulation de saisie au clavier. Je posterais une autre question pour me renseigner à ce sujet. Désolé je n'ai pu t'avoir qu'à mi-chemin. L'autre option serait d'utiliser un ordinateur Windows avec Microsoft Excel, bien que je ne sois pas sûr que ce soit une option pour vous dans ce cas.


Extrait de leur readme

Alternativement, vous pouvez utiliser halo avec l'instruction avec Python :

Enfin, vous pouvez utiliser halo comme décorateur :

Version améliorée de @Victor Moyseenko car la version originale avait peu de problèmes

  1. quittait les personnages du fileur une fois le filage terminé
  2. et parfois conduire à supprimer également le premier caractère de la sortie suivante
  3. évite une condition de concurrence rare en mettant threading.Lock() sur la sortie
  4. revient à une sortie plus simple lorsqu'aucun tty n'est disponible (pas de rotation)

exemple d'utilisation de la classe Spinner ci-dessus :

Bien sûr, c'est possible. Il s'agit simplement d'imprimer le caractère de retour arrière (  ) entre les quatre caractères qui donnerait l'impression que le "curseur" tourne ( - , , | , / ).

module de malédictions. je regarderais les fonctions addstr() et addch(). Jamais utilisé par contre.

Pour des manipulations de console plus avancées, sur unix, vous pouvez utiliser le module python curses, et sur Windows, vous pouvez utiliser WConio qui fournit des fonctionnalités équivalentes à la bibliothèque curses.

Prenez le module de barre de progression génial - http://code.google.com/p/python-progressbar/ utilisez RotatingMarker .

J'ai trouvé le package py-spin sur GitHub. Il a beaucoup de beaux styles de filature. Voici quelques exemples d'utilisation, Spin1 est le style -/ :

Il est également possible de contrôler le spin manuellement :

Autres styles dans le gif ci-dessous.

AVERTISSEMENTS : D'après mon expérience, cela ne fonctionne pas dans tous les terminaux. Un moyen plus robuste de le faire sous Unix/Linux, même plus compliqué, est d'utiliser le module curses, qui ne fonctionne pas sous Windows. Vous voudrez probablement le ralentir d'une certaine manière avec le traitement réel qui se déroule en arrière-plan.

Voilà, c'est simple et clair.

Solution grossière mais simple :

Il y a des limites évidentes, mais encore une fois, brutes.

Je propose une solution en utilisant des décorateurs

J'ai construit un Singleton générique, partagé par l'ensemble de l'application

Cela peut être aussi une autre solution en utilisant une fonction avec un paramètre.

Vous pouvez écrire ' 33[K' pour effacer la ligne actuelle. Et ce qui suit est un exemple modifié de @nos.

Pour tous ceux qui s'intéressent à nodejs, j'écris également un exemple de nodejs.

Je viens de commencer avec python il y a environ une semaine et j'ai trouvé cette publication. J'ai combiné un peu de ce que j'ai trouvé ici avec des choses que j'ai apprises sur les threads et les files d'attente ailleurs pour fournir une bien meilleure implémentation à mon avis. Dans ma solution, l'écriture à l'écran est gérée par un thread qui vérifie le contenu d'une file d'attente. Si cette file d'attente a du contenu, le fil de rotation du curseur sait s'arrêter. D'un autre côté, le fil de rotation du curseur utilise une file d'attente comme verrou afin que le fil d'impression sache ne pas imprimer tant qu'un passage complet du code de rotation n'est pas terminé. Cela empêche les conditions de concurrence et de nombreux excès de code que les gens utilisent pour garder la console propre.

Après avoir dit tout ce que j'ai dit et écrit tout ce que j'ai écrit, je ne fais des trucs en python que depuis une semaine. S'il existe des moyens plus propres de le faire ou si j'ai raté certaines des meilleures pratiques, j'aimerais apprendre. Merci.


Principaux indicateurs de performance du site Web

Puisque vous savez déjà quel type d'outil de surveillance convient à votre site Web, la prochaine chose à considérer est les bons indicateurs de performance pour votre site Web. C'est une tâche ardue car la recherche des « bonnes » métriques est écrasante.

Cependant, la bonne métrique dépend toujours de votre site Web et du type d'entreprise. La meilleure pratique consiste à classer les problèmes en fonction de leur gravité. Par exemple, un propriétaire d'entreprise ne souhaite pas recevoir un flot d'avertissements concernant des liens rompus ou de légères modifications de la vitesse de chargement. Laissez ces types d'alertes à l'équipe de développement car cela pourrait bloquer des problèmes critiques tels que les temps d'arrêt de l'infrastructure.

Voici dix indicateurs de performance de site Web que chaque propriétaire de site Web devrait surveiller.

Disponibilité

La présence en ligne n'est plus une option, car la plupart des entreprises dépendent fortement de leur site Web. Si un site Web est en panne pendant quelques minutes ou a une page à chargement lent au-delà du temps recommandé, cela affecte directement les revenus. De plus, un site Web inaccessible perturbe les processus commerciaux et les flux de travail. En conséquence, les temps d'arrêt prolongés et leur fréquence peuvent ruiner la réputation de toute votre entreprise.

Mais nous ne sommes pas là pour lutter contre les temps d'arrêt. Au lieu de cela, parlons de Disponibilité. La surveillance de la disponibilité est l'indicateur de performance critique d'un site Web. En tant que propriétaire de site Web, vous devez vous efforcer d'atteindre les «cinq neuf». Cela signifie que votre site Web doit avoir une disponibilité de 99,999%. De plus, il est recommandé de vérifier la disponibilité de votre site Web à partir de différents emplacements.

Temps jusqu'au premier octet (TTFB)

Le temps jusqu'au premier octet (TTFB) mesure la réactivité d'un serveur ou d'autres ressources réseau. Il mesure le temps écoulé entre l'utilisateur ou le client effectuant une requête HTTP et le premier octet de la page reçu par le navigateur du client.

En quoi un indicateur de performance est-il pertinent ? La réponse est simple. La plupart des utilisateurs en ligne sont impatients. Selon ce article de Neil Patel, un site n'a que trois secondes pour se charger avant de perdre 40 % de ses visiteurs. Ainsi, si votre page ne se charge pas rapidement, les visiteurs en ligne partiront très probablement même si vous avez un excellent contenu.

La meilleure façon de tirer parti de cet indicateur de performance est d'envoyer des demandes à partir de différents emplacements. Vérifiez la vitesse de réponse de votre serveur Web pendant les heures de pointe et les heures creuses.

Le TTFB se mesure au sein de ces trois actions :

  1. Envoi d'une requête au serveur
  2. Traitement et génération de la réponse
  3. Renvoyer la réponse au client

Temps de chargement en pleine page

En règle générale, un visiteur du site Web n'interagit avec votre page que si elle est complètement chargée. Cela signifie que tous ses attributs de boutons, d'images et de vidéos sont en place. C'est ainsi que fonctionne le temps de chargement d'une page entière. Par conséquent, le temps de chargement d'une page complète correspond au moment où il faut télécharger le code source d'une page spécifique.

Alors, comment mesurer le temps de chargement d'une page entière ? Vous pouvez utiliser Surveillance des performances des applications(APM) des solutions pour vous aider avec cet indicateur. Il facilite tracé de votre code source et fournit des informations sur la vitesse de votre site Web.

N'oubliez pas que les utilisateurs préfèrent les sites Web à chargement rapide. Voyons quelques cas d'utilisation :

  • Une entreprise a subi une perte de revenus de 1 % par 100 millisecondes de retard de chargement du site.
  • Un site Web d'entreprise doit augmenter son taux de conversion de 1,5%.
  • Une entreprise souhaite réduire son temps de chargement pour améliorer les conversions.

Vous pouvez résoudre ces scénarios à l'aide d'outils de surveillance des performances avec une journalisation centralisée et une surveillance des utilisateurs réels.

Toujours pas convaincu ? Que diriez-vous d'élargir notre discussion non seulement avec l'expérience utilisateur, mais avec les classements de recherche organique. Google a inclus la vitesse de la page, la profondeur du contenu et la convivialité mobile dans les facteurs de classement de l'algorithme.

De plus, quels que soient la taille de la page et l'intervalle d'analyse, la surveillance de pleine page crée beaucoup de trafic de bande passante. Ainsi, le moyen le plus simple d'obtenir un temps de chargement rapide d'une page entière consiste à réduire la taille de l'image.

Liens brisés

Les hyperliens constituent l'ensemble du Web. Ainsi, il est inévitable d'avoir des liens rompus. Un site Web avec des liens menant à une erreur 404 est un problème simple mais peut être catastrophique. En un mot, ni les utilisateurs de votre site Web ni les moteurs de recherche, comme Google, n'aiment les liens rompus.

Peut-être avez-vous simplement mal orthographié l'URL de destination ou la page liée n'existe plus ? L'essentiel est que les liens rompus sont mauvais pour les affaires.

Effectuez une maintenance régulière et vérifiez les liens brisés. Pour vous aider, souvenez-vous toujours de ceux-ci lorsque vous traitez des liens rompus :

  • Les liens brisés frustrent vos visiteurs et peuvent nuire à votre réputation.
  • Cela donne l'impression que vous n'effectuez pas de « ménage régulier ».
  • Ils pourraient affecter votre taux de conversion.
  • Les liens brisés entravent l'optimisation du classement de vos pages.

Parcours utilisateur

Le parcours utilisateur est un autre indicateur de performance important car il vous aide à vous améliorer en continu. Il détermine si vous avez le bon flux de travail. Un flux de travail efficace garantit à vos utilisateurs une expérience utilisateur exceptionnelle.

Un processus de commande qui fonctionne correctement est vital pour les sites Web de commerce électronique. Assurez-vous que vos utilisateurs naviguent et contournent l'ensemble du processus de manière transparente. De même, la connexion au site Web pour les clients ou les utilisateurs enregistrés est un autre processus intégral qui devrait être sans erreur. Les problèmes de connexion récurrents tels que les problèmes de connexion multiples frustrent les utilisateurs et empêchent les clients d'acheter.

Enfin, pour les sites Web de génération de leads, vous devez vérifier si votre inscription à la newsletter fonctionne correctement. Une erreur de workflow lors du processus d'abonnement entraîne une perte potentielle de clients.

Performances de la base de données

Pourquoi les performances de la base de données sont-elles importantes ? La plupart des sites Web contiennent du contenu dynamique extrait d'une base de données. C'est un autre indicateur de performance Web essentiel pour assurer le bon fonctionnement d'un site Web.

Dans la plupart des cas, un site Web à réponse très lente a une base de données peu performante. Par conséquent, vous devez surveiller le temps de réponse de vos requêtes de base de données. Recherchez les requêtes qui prennent le plus de temps et effectuez une optimisation.

C'est une tâche ardue, mais vous pouvez aller de l'avant avec APM comme Retrace car vous pouvez surveiller les performances globales de votre base de données. Il s'agit d'un APM riche en fonctionnalités qui vous aide à déterminer s'il existe un goulot d'étranglement. Si les résultats de vos requêtes contiennent des messages d'erreur ou renvoient des résultats en dehors de la plage attendue, Retrace fournit des alertes.

Performance géographique

Avec l'avènement d'Internet rapide, la vitesse et la disponibilité du site Web dans différentes parties du monde ne devraient plus être un problème. La performance géographique est un indicateur qui garantit aux clients une accessibilité transparente de votre service quel que soit l'emplacement.

Il est essentiel pour les entreprises actives à l'échelle mondiale ou celles qui s'adressent à des clients du monde entier. La plupart des entreprises élaborent des plans d'infrastructure en sécurisant les emplacements de serveurs les plus proches. Il est essentiel d'augmenter la vitesse du site Web.

La plupart des entreprises tirent parti de leurs analyses de données pour déterminer l'état de leurs performances géographiques. Le suivi de vos performances géographiques est vital et la priorité absolue est de choisir les emplacements sur lesquels se concentrer. Vous pouvez utiliser vos analyses de données pour surveiller les performances d'un emplacement spécifique ou les performances globales.

Matériel du serveur Web

La surveillance de l'espace disque libre est importante dans le fonctionnement du site Web. Il y a plusieurs erreurs provoquées par moins d'espace disque. Il comprend des fichiers journaux, des entrées de base de données, des photos et des fichiers vidéo qui peuvent consommer une quantité importante d'espace disque.

En conséquence, un espace disque réduit et une charge CPU élevée entraînent une défaillance du site Web. Une charge CPU élevée signifie que de nombreux processus actifs submergent votre CPU et ralentissent l'ensemble du serveur. Lorsque vous travaillez avec des sites Web, il existe plusieurs causes d'utilisation élevée du processeur. Un exemple est qu'une nouvelle fonctionnalité pourrait être responsable de l'augmentation du trafic.

La surveillance régulière de l'utilisation du processeur empêche de nombreuses pannes de serveur Web. Vous devriez envisager de mettre à niveau votre matériel si vous rencontrez un processeur élevé sur une longue période. De plus, avec la surveillance du processeur, gardez également un œil sur l'utilisation de la mémoire.

Visiteurs du site Web

Le trafic du site Web est un indicateur de performance important pour le succès de votre présence en ligne. C'est un moyen de tester et d'évaluer les charges que votre site Web peut supporter. Lorsque vous gagnez du terrain avec votre trafic en ligne, les principales considérations devraient être de mettre à niveau vos serveurs Web. Ne soyez pas complaisant si vos serveurs peuvent gérer le trafic du site Web la plupart du temps. Considérez ce qui se passera si de nombreuses personnes visitent votre site en même temps.

D'un autre côté, si le nombre de visiteurs du site Web diminue, il peut y avoir un problème technique ou votre contenu n'est pas assez engageant.

Qualité du site Web

Le dernier indicateur est la qualité du site Web. Vous pouvez avoir tous les indicateurs de performance technique, mais vous devez garder un œil sur la qualité de votre site Web. L'audit qualité du site est un processus manuel et doit être effectué régulièrement.

Tenez compte des questions suivantes lors de l'audit de la qualité de votre site Web :

  • L'interface utilisateur du site Web est-elle appropriée et attrayante ?
  • Chaque page a-t-elle un objectif clair ?
  • Le texte est-il bien structuré et lisible ?
  • Le style de rédaction est-il adapté au public cible ?
  • Fournit-il des informations précieuses aux utilisateurs et aux visiteurs ?

Échec des questions d'examen de test

Lorsqu'un nouveau message est ajouté à la file d'attente SQS, il est masqué pour les instances de consommateur pendant une période déterminée.

Lorsqu'une instance de consommateur récupère un message, ce message est masqué dans la file d'attente pendant une période déterminée.

Lorsque l'instance du consommateur recherche un nouveau travail, le service SQS lui permet d'attendre un certain temps qu'un ou plusieurs messages soient disponibles avant de fermer la connexion.

Lors du traitement d'un message, une instance consommateur peut modifier le compteur de visibilité du message d'un montant fixe

Lors du traitement d'un message, une instance de consommateur peut réinitialiser la visibilité du message en redémarrant le compteur de délai d'attente prédéfini.

Travaillez avec votre équipe de conception Web pour créer des pages Web avec des scripts Java intégrés pour émuler vos 5 pages Web d'informations les plus populaires et vous inscrire à des pages Web.

Mettez à niveau votre serveur existant d'un Ixlarge à un 32xlarge pour la durée de la campagne.

Créez une page d'inscription en double qui stocke les détails d'inscription dans DynamoDB pour un traitement asynchrone à l'aide de SQS et de Lambda.

Travaillez avec votre équipe de conception Web pour créer des pages Web en PHP à exécuter sur une instance EC2 32xlarge pour émuler vos 5 pages Web d'informations les plus populaires et les pages Web d'inscription.

Recréez vos 5 pages Web les plus populaires pour les nouveaux clients et inscrivez-vous à des pages Web sur Lightsail et profitez de la mise à l'échelle automatique d'AWS pour récupérer la charge.

Lorsqu'un nouveau message est ajouté à la file d'attente SQS, il sera masqué des instances de consommateur pendant une période déterminée

Lors du traitement d'un message, une instance de consommateur peut réinitialiser la visibilité du message en redémarrant le compteur de délai d'attente prédéfini.

Lors du traitement d'un message, une instance consommateur peut modifier le compteur de visibilité du message d'un montant fixe

Lorsque l'instance du consommateur recherche un nouveau travail, le service SQS lui permet d'attendre un certain temps qu'un message soit disponible avant de fermer la connexion.

Lorsqu'une instance de consommateur récupère un message, ce message sera masqué aux autres instances de consommateur pendant une période déterminée.

utiliser un Elastic Load Balancer, un déploiement multi-AZ d'un groupe Auto-Scaling d'instances EC2 Spat (principales) s'exécutant en tandem avec un groupe Auto-Scaling d'instances EC2 à la demande (secondaires), DynamoD

2. utiliser un Elastic Load Balancer, un déploiement multi-AZ d'un groupe Auto-Scaling d'instances à la demande EC2 (principales) s'exécutant en tandem avec un groupe Auto-Scaling d'instances EQ Spot (secondaire), un déploiement multi-AZ de RDS.

3.utiliser un Elastic Load Balancer, un déploiement multi-AZ d'un groupe Auto-Scaling d'instances Spot EC2 (principales) s'exécutant en tandem avec un groupe Auto-Scaling d'instances EC2 à la demande (secondaires), un déploiement multi-AZ de RDS.

1Créez un utilisateur IAM avec une stratégie qui peut lire le groupe de sécurité et les paramètres NACL.

2Créez un rôle IAM avec une stratégie qui peut lire le groupe de sécurité et les paramètres NACL.

3Créez un rôle IAM avec une stratégie qui peut lire les paramètres de groupe de sécurité et de routage.

4Expliquez qu'AWS implémente la sécurité du réseau différemment et qu'il n'existe pas d'appliance de pare-feu. Vous pouvez ensuite suggérer au consultant de suivre le cours AWS CSA-A « Un gourou du cloud » en vue de l'audit.

5Créez un utilisateur IAM avec une stratégie qui peut lire les paramètres de groupe de sécurité et de routage.

4 Expliquez qu'AWS implémente la sécurité du réseau différemment et qu'il n'existe pas d'appliance de pare-feu. Vous pouvez ensuite suggérer au consultant de suivre le cours AWS CSA-A « Un gourou du cloud » en préparation de l'audit.

Activez la vérification de la source/destination sur l'instance NAT.

Configurez tout le trafic pour qu'il sorte via Elastic Load Balancer.

Désactivez la vérification de source/destination sur votre instance NAT.

Lors du traitement d'un message, une instance consommateur peut modifier le compteur de visibilité du message d'un montant fixe.

Lors du traitement d'un message, une instance de consommateur peut réinitialiser la visibilité du message en redémarrant le compteur de délai d'attente prédéfini.

Lorsque l'instance consommateur recherche de nouveaux travaux, le service SQS lui permet d'attendre un certain temps qu'un message soit disponible avant de fermer la connexion.

Lorsqu'un nouveau message est ajouté à la file d'attente SQS, il sera masqué des instances de consommateur pendant une période déterminée

Lorsqu'une instance de consommateur récupère un message, ce message est masqué dans la file d'attente pendant une période déterminée.

6Suggérer que pendant la transition, une deuxième solution AWS Storage Gateway VTL pourrait être mise en service dans le nouveau VPC du client et intégrée au VTS existant. Dans le même temps, la solution de sauvegarde d'entreprise existante pourrait être utilisée pour effectuer des copies de bande à bande afin de migrer les archives de la bande vers la bande virtuelle VTL/VTS.


Conseils sur les groupes de sécurité et quels ports ont un accès illimité


Déployez votre site Web dans 2 régions différentes. Configurez Route 53 avec une stratégie de routage de basculement et configurez des vérifications de l'état sur le site principal.

Amazon FSx for Lustre permet de lancer et d'exécuter facilement et à moindre coût le système de fichiers hautes performances le plus populaire au monde. Il est utilisé pour des charges de travail telles que l'apprentissage automatique, le calcul haute performance (HPC), le traitement vidéo et la modélisation financière. Le système de fichiers open source Lustre est conçu pour les applications qui nécessitent un stockage rapide - où vous souhaitez que votre stockage suive votre calcul. FSx for Lustre s'intègre à Amazon S3, ce qui facilite le traitement des ensembles de données avec le système de fichiers Lustre. Lorsqu'il est lié à un compartiment S3, un système de fichiers FSx for Lustre présente de manière transparente les objets S3 sous forme de fichiers et vous permet de réécrire les données modifiées dans S3.
FSx for Lustre offre la possibilité à la fois de traiter les « données chaudes » de manière parallèle et distribuée, ainsi que de stocker facilement les « données froides » sur Amazon S3. Par conséquent, cette option est la MEILLEURE solution pour l'énoncé du problème donné.

Options incorrectes :
Amazon FSx pour Windows File Server - Amazon FSx pour Windows File Server fournit un stockage de fichiers entièrement géré et hautement fiable qui est accessible via le protocole SMB (Service Message Block) standard. Il est basé sur Windows Server, offrant un large éventail de fonctionnalités administratives telles que les quotas d'utilisateurs, la restauration de fichiers de l'utilisateur final et l'intégration de Microsoft Active Directory (AD). FSx pour Windows ne vous permet pas de présenter des objets S3 sous forme de fichiers et ne vous permet pas de réécrire les données modifiées dans S3. Par conséquent, vous ne pouvez pas référencer les "données froides" avec un accès rapide pour des lectures et des mises à jour à faible coût. Cette option n'est donc pas correcte.

Amazon EMR - Amazon EMR est la plate-forme de big data cloud leader du secteur pour le traitement de grandes quantités de données à l'aide d'outils open source tels qu'Apache Spark, Apache Hive, Apache HBase, Apache Flink, Apache Hudi et Presto. Amazon EMR utilise Hadoop, une infrastructure open source, pour distribuer vos données et leur traitement sur un cluster redimensionnable d'instances Amazon EC2. EMR n'offre pas la même vitesse de stockage et de traitement que FSx pour Lustre. Ce n'est donc pas la bonne solution pour le scénario de flux de travail hautes performances donné.


12 réponses 12

Les fabricants d'automates aimeraient vous faire croire que leurs logiciels sont plus fiables et mieux testés. J'ai l'impression que les principaux composants du système d'exploitation des API sont généralement assez bien conçus et testés, mais les pilotes pour le matériel externe (systèmes de mouvement et autres) sont souvent des bibliothèques piratées par les ingénieurs d'applications, puis diffusées dans l'entreprise. Le matériel des automates programmables est souvent obsolète - beaucoup d'entre eux utilisent de vieux processeurs Geode chauds.

Lorsque vous achetez un automate programmable auprès d'Allen-Bradley, de B&R, de Siemens ou de l'un des autres grands acteurs, vous payez principalement pour l'assistance lorsque les choses tournent mal. Leur matériel est fabriqué avec les mêmes processus de fabrication que les Arduinos, et il n'y a rien de magique dans les systèmes d'exploitation en temps réel fonctionnant sur des automates qui les rendent sans bogue. Mais, je pense que le soutien vaut souvent la peine d'être payé. S'il s'agit d'une machine qui coûte à l'entreprise 1 million de dollars chaque jour où elle ne fonctionne pas, je serais sûr qu'en cas de problème, une équipe de professionnels pouvait aider à le réparer, pas seulement moi et Google. Pour le cas spécifique des barrières immatérielles ou d'autres verrouillages de sécurité, je voudrais m'assurer que le fabricant a une police d'assurance lourde en place, plutôt qu'une déclaration qui essaie de décliner toute valeur marchande pour un usage particulier.

Même ainsi, si je concevais (par exemple) un petit actionnement pneumatique simple pour un appareil, et que j'étais prêt à assumer le fardeau de la réparation de la machine en cas de panne (ou si je n'étais pas en mesure d'obtenir les ressources allouées payer pour le PLC), et la sécurité n'était pas un problème, j'utiliserais volontiers un Arduino.

Je prototyperais probablement le système avec un Arduino, puis réécrirais le code en C pur une fois qu'il fonctionnait, de sorte que mon code soit le seul code sur le microcontrôleur.

Arduino lui-même n'est pas bon pour les applications industrielles en raison du manque de protection et de blindage appropriés. Mais il est possible de fabriquer des contrôleurs à base d'AVR de qualité industrielle :

Vous devriez avoir un blindage, un filtrage/régulation/protection de l'alimentation, des paires optiques pour piloter des objets externes, des capuchons de découplage décents sur chaque puce numérique.

Vous devez le tester très attentivement lors de l'activation/désactivation de charges élevées, il est préférable de vérifier si vous avez des problèmes sur les lignes de masse/d'alimentation/de données lors de cette commutation avec l'oscilloscope (jusqu'à 1 ns).

Vous devez vérifier votre source d'horloge très attentivement - l'AVR ne se replie pas sur l'oscillateur RC en cas de défaillance de l'oscillateur à cristal. Vous feriez donc mieux de vous en tenir à la RC interne si vous n'avez pas besoin de précision d'horloge ou si vous n'accordez pas une attention particulière au routage du cristal, aux condensateurs de charge, à la qualité du PCB (= rappels de flux, protection contre l'humidité) et au blindage autour du cristal.

Il existe de meilleurs uC pour les applications industrielles, notamment avec cette fonction de repli RC.

Avant le API, le contrôle des processus industriels a été effectué par le relais logix (pour le contrôle numérique) et Contrôleurs PID pour le contrôle analogique. Les relais étaient notoirement peu fiables, dont la défaillance avait dans certains cas de graves conséquences. Malgré cela, la suggestion que cela pourrait être mieux exécuté par un ordinateur fonctionnement Logiciel avec des sorties à semi-conducteurs au lieu de relais horrifié la plupart des ingénieurs électriciens à l'époque. Les arguments contre l'adoption des PLC à cette époque étaient similaires à certains des arguments dans les réponses de ce forum. Résistez aux suggestions intéressantes et vous êtes certain d'être en bonne compagnie. Des considérations économiques, de temps d'arrêt et de maintenance ont conduit (lentement) à la transition du contrôle câblé au contrôle par microcontrôleur/logiciel. Je me souviens plus récemment, de l'horreur avec laquelle Ethernet et les différents protocoles associés à l'époque ont été accueillis par l'établissement de contrôle. Ethernet est en train de devenir rapidement la norme de facto pour le contrôle des processus.

De nos jours, dans les systèmes de contrôle les plus sophistiqués, les processus critiques pour la sécurité ont toujours une sauvegarde câblée/pneumatique/hydraulique/mécanique, ou au moins un état de sécurité intégrée. L'interface opérateur avec le système de contrôle est une partie essentielle du système de contrôle, qui, en dehors du contrôle de la machine, est dans la plupart des cas un ordinateur de bureau du magasin de PC local, avec un système d'exploitation buggy/crash-crash qui applications de contrôle de processus sujettes. Ce n'est pas exagéré. Nous avons conçu et construit des usines dans les environnements les plus difficiles des industries chimiques et minières où la poussière et les fumées font partie de la vie, même dans la salle de contrôle, et n'avons pas plus de défaillances d'équipements grand public/commerciaux standard que de équipement industriel. Les disques durs tombent en panne mais ils sont scellés. Ils échouent de toute façon. Nous soufflons régulièrement des nuages ​​de poussière industrielle de cartes mères de PC qui exécutent les IHM. L'astuce est d'avoir une redondance double/triple dans tous les systèmes importants/critiques. Tout peut échouer. C'est pourquoi les éléments critiques pour la sécurité sont toujours sauvegardés par du matériel, et il s'agit d'une exigence législative dans plus pays et le bon sens dans d'autres.

Si l'on veut amener l'aviation dans la discussion, n'oubliez pas l'horreur avec laquelle les constructeurs d'avions non Airbus ont rencontré la suggestion de voler par fil. Dans les accidents aériens, l'erreur humaine (principalement le pilote mais aussi le personnel de maintenance), et non la défaillance technique/des systèmes, représente toujours de loin la plupart des accidents. Dans l'espace industriel/commercial des automates/microcontrôleurs, je dirais que l'humain au niveau du terminal de programmation est toujours l'élément le plus critique. La CONCEPTION, la STRUCTURE et la MAINTENANCE du logiciel sont les ingrédients essentiels plutôt que le matériel.

Rockwell propose le produit SoftLogix qui est un automate logiciel fonctionnant sur un PC de magasin standard. Pensez-y. L'argument selon lequel les PC fonctionnent dans un environnement électrique/atmosphérique plus protégé que les automates/contrôleurs peut être vrai dans certains cas, mais pas dans la plupart, et très peu dans les usines que nous desservons. L'ironie est que la prolifération d'Ethernet nécessite des commutateurs Ethernet sur le terrain. En règle générale, nous n'utilisons pas de commutateurs industriels, mais des produits commerciaux standard et nous n'avons pas encore eu de panne de commutateur après 10 ans et des centaines d'installations. Ces commutateurs résident dans les mêmes panneaux que les E/S de l'API. Ce qui échoue, mais rarement, c'est l'alimentation électrique bon marché qui accompagne le commutateur. Évitez cela et le commutateur ne sera pas le composant le moins fiable de l'installation.

En ce qui concerne les tests/contrôles de qualité rigoureux des équipements PLC industriels, j'ai récemment mis en service une usine où CHACUNE des 8 ou 10 cartes d'entrées analogiques d'E/S distantes était DOA. Le fournisseur, l'une des plus grandes marques au monde, n'a pas sourcillé et a tout remplacé immédiatement. Je suppose que c'était un mauvais lot et qu'ils auraient pu connaître le problème avant notre rapport. Les remplacements ont parfaitement fonctionné et le font encore 3 ans plus tard.

La peur est utilisée partout de nos jours pour nous intimider. Utilisez la raison et, comme le disaient certains anciens, « sucez-le et voyez (par vous-même) ». Je n'aurais aucune hésitation à tester des microcontrôleurs « non industriels » n'importe où. Il suffit de suivre les bonnes pratiques d'ingénierie, de quantifier le risque et d'agir de manière appropriée. Incidemment, les véhicules à moteur fonctionnent dans des conditions assez proches de certaines conditions industrielles (humide, chaud, vibrations) mais disposent de nombreux systèmes électroniques critiques pour la sécurité. Essayez maintenant de suggérer à un ingénieur en systèmes de contrôle industriel que vous êtes sur le point d'essayer un composant automobile dans votre usine ! CANbus ou DNET n'importe qui ? Allez comprendre (:)


Super, nous sommes condamnés ! - Que faisons-nous à propos de cela?

Eh bien, à la fin, tout ce qui précède tient toujours. Si vous ne pouvez pas extraire la majeure partie de la programmation de ce système pour utiliser des outils et des langages plus courants, vous devez "juste" l'adapter aux contraintes de votre système.

À propos de la gestion des versions et du stockage

En fin de compte, vous pouvez presque toujours version choses, même avec l'environnement le plus contraint et fortifié. Le plus souvent, ces systèmes sont toujours livrés avec leur propre versioning (qui est malheureusement souvent assez basique, et propose juste de revenir aux versions précédentes sans beaucoup de visibilité, en gardant juste les instantanés précédents). Il n'utilise pas exactement des ensembles de modifications différentiels comme le SCM de votre choix, et il n'est probablement pas adapté pour plusieurs utilisateurs soumettant des modifications simultanément.

Mais quand même, s'ils fournissent une telle fonctionnalité, votre solution consiste peut-être à suivre nos directives standard bien-aimées ci-dessus et à les transposer à ce système de programmation !

Si le système de stockage est une base de données, il expose probablement des fonctionnalités d'exportation ou peut être sauvegardé au niveau du système de fichiers. S'il utilise un format binaire personnalisé, vous pouvez peut-être simplement essayer de le versionner avec un VCS qui prend bien en charge les données binaires. Vous n'aurez pas un contrôle précis, mais au moins vous serez en quelque sorte couvert contre les catastrophes et aurez un certain degré de conformité à la reprise après sinistre.

À propos des tests

Implémentez vos tests au sein de la plate-forme elle-même et utilisez des outils externes et des tâches en arrière-plan pour configurer des sauvegardes régulières. Très probablement, vous lancez ces tests de la même manière que vous lanceriez les programmes développés avec ce système de programmation.

Bien sûr, c'est un travail de piratage et certainement pas à la hauteur de ce qui est courant pour la programmation "normale", mais l'idée est de s'adapter au système tout en essayant de maintenir un semblant de processus de développement logiciel professionnel.

La route est longue et escarpée.

Comme toujours avec les environnements de niche et les systèmes de programmation sur mesure, et comme nous l'avons exposé ci-dessus, vous traitez avec des formats étranges, seulement un ensemble limité (ou totalement inexistant) d'outils éventuellement maladroits, et un vide à la place d'une communauté.

La recommandation : Essayez de mettre en œuvre les directives ci-dessus en dehors de votre système de programmation sur mesure, autant que possible. Cela garantit que vous pouvez compter sur des outils "communs", qui bénéficient d'un soutien approprié et d'un dynamisme communautaire.

La solution de contournement : Lorsque ce n'est pas une option, essayez de réinstaller ce cadre global dans votre "boîte". L'idée est de superposer ce modèle des meilleures pratiques standard de l'industrie à votre système de programmation et d'en tirer le meilleur parti. Le conseil reste d'actualité : définir la structure et les bonnes pratiques, encourager la conformité.

Malheureusement, cela implique que vous devrez peut-être plonger et faire une énorme quantité de travail sur les jambes. Alors.

Derniers mots célèbres et demandes humbles :

  • Document tout ce que tu fais.
  • Partager ton expérience.
  • Open source n'importe quel outil que vous écrivez.

En faisant tout cela, vous allez :

  • non seulement augmenter vos chances d'obtenir le soutien de personnes dans des situations similaires,
  • mais aussi fournir de l'aide à d'autres personnes et favoriser la discussion autour de votre pile technologique.

Qui sait, vous pourriez être au tout début d'une nouvelle communauté dynamique de Langage obscur X. S'il n'y en a pas, lancez-en un !

Peut-être qu'il fait beau à l'intérieur, mais personne n'a la moindre idée jusqu'ici, alors aidez-moi abattre ce mur laid et laissez les autres jeter un coup d'œil !

La très premier pas serait introduction d'un système de contrôle de version (SVN, Git, Mercurial, TFS, etc.). C'est indispensable pour un projet qui aura un refactoring.

Éditer: concernant VSC - Chaque package de contrôle de source peut gérer les binaires, bien qu'avec certaines limitations. La plupart des outils du marché ont la possibilité d'utiliser un visualiseur et un éditeur de différences personnalisés, utilisez cette capacité. Les fichiers sources binaires ne sont pas une excuse de ne pas utiliser le contrôle de version.

Il y a un article similaire sur la façon de gérer le code hérité, cela pourrait être une bonne référence à suivre - Conseils sur l'utilisation du code hérité

Quand je dois travailler avec du code spaghetti, la première chose sur laquelle je travaille est modularisation. Trouvez des endroits où vous pouvez tracer des lignes et extraire (plus ou moins) des morceaux indépendants de la base de code. Ils ne seront probablement pas très petits, en raison d'un degré élevé d'interconnexion et de couplage, mais certaines lignes de modules émergeront si vous les recherchez.

Une fois que vous avez des modules, vous n'êtes plus confronté à la tâche intimidante de nettoyer tout un programme désordonné. Maintenant, à la place, vous avez plusieurs petits modules désordonnés indépendants à nettoyer. Choisissez maintenant un module et répétez à plus petite échelle. Trouvez des endroits où vous pouvez extraire de grandes fonctions dans des fonctions plus petites ou même des classes (si G2 les prend en charge).

Tout cela est beaucoup plus facile si le langage a un système de types suffisamment puissant, car vous pouvez demander au compilateur de faire le gros du travail à votre place. Vous apportez une modification quelque part qui rompra (intentionnellement) la compatibilité, puis essayez de compiler. Les erreurs de compilation vous mèneront directement aux endroits qui doivent être modifiés, et lorsque vous arrêtez de les obtenir, vous avez tout trouvé. Ensuite, lancez le programme et testez tout ! Les tests continus sont d'une importance cruciale lors de la refactorisation.

Je ne sais pas si c'est une option pour vous, mais je commencerais à essayer de les convaincre de embaucher plus de développeurs professionnels. De cette façon, ils pourraient se concentrer sur les problèmes de domaine (je suis sûr qu'ils en ont assez).

Je pense que ce sont des gens très intelligents, mais devenir un bon développeur demande beaucoup de temps. Sont-ils prêts à consacrer autant de temps à une activité qui n'est pas leur activité principale ? À mon humble avis, ce n'est pas le moyen d'obtenir les meilleurs résultats.

Wow. On dirait que vous avez un très gros défi devant vous ! Je ferais quelque chose du genre :

  • D'abord: Prioriser. Que voulez-vous réaliser en premier ? Quel est le plus important pour l'état actuel du projet? De quoi tirerez-vous le meilleur parti par rapport au temps qu'il vous faudra pour y arriver.
  • Assurez-vous d'avoir un contrôle de version système. Git ou Mercurial par exemple.
  • Obtenez une sorte de Intégration continue système (par exemple Jenkins) opérationnel.
  • Obtenir un suivi des bogues système opérationnel. Mantis est assez sympa à mon avis.
  • Examiner analyse de code statique (si quelque chose est disponible pour la langue avec laquelle vous travaillez actuellement).
  • Essayez d'en faire autant cohérence dans tout, de la dénomination des variables aux conventions générales du code et aux directives de la base de code.
  • Faites tester le système. C'est extrêmement important pour un grand système hérité comme celui-ci à mon avis. Utiliser des cas de test pour documenter le comportement existant, peu importe si le comportement semble étrange ou non (généralement, il y a une raison pour laquelle le code a l'air d'un certain pourquoi, peut être bon ou mauvais, ou les deux P). Michael Feathers Working Effectively With Legacy Code est une excellente ressource pour cela.

Ils disent que la première étape pour résoudre un problème est d'admettre que vous en avez un. Dans cet esprit, vous pouvez commencer par générer un graphique de dépendance qui illustre le vaste enchevêtrement de votre base de code actuelle. Bon outil pour générer un diagramme de dépendances ? a quelques années mais contient des pointeurs vers des outils qui peuvent aider à créer de tels graphiques. J'irais avec un très gros graphique laid qui montre autant que possible pour enfoncer le clou. Parlez des problèmes qui résultent de trop d'interdépendances et lancez peut-être une réplique de Buckaroo Banzai :

Vous pouvez vérifier votre anatomie autant que vous voulez, et même s'il peut y avoir des variations normales, en fin de compte, si loin à l'intérieur de la tête, tout se ressemble. Non, non, non, ne tirez pas dessus. On ne sait jamais à quoi il peut être attaché.

À partir de là, présentez un plan pour commencer à redresser la situation. Divisez le code en modules aussi autonomes que possible. Soyez ouvert aux suggestions sur la façon de procéder - les personnes à qui vous parlez connaissent mieux que vous l'historique et les fonctionnalités du code. L'objectif, cependant, est de prendre un gros problème et de le transformer en un certain nombre de problèmes plus petits que vous pouvez ensuite hiérarchiser et commencer à nettoyer.

Créez des interfaces propres entre les modules et commencez à les utiliser. L'ancien code peut, par nécessité, continuer à ne pas utiliser ces nouvelles interfaces sympas pendant un certain temps - c'est le problème que vous commencez à résoudre. Mais amenez tout le monde à accepter de n'utiliser que les nouvelles interfaces à l'avenir. S'il y a quelque chose dont ils ont besoin qui ne se trouve pas dans les interfaces, réparez les interfaces, ne les contournez pas.

Recherchez les cas où la même fonctionnalité a été répétée. Travailler à l'unification.

Rappelez à tout le monde de temps en temps que ces changements sont destinés à rendre la vie plus facile, pas plus difficile. La transition peut être douloureuse, mais c'est pour une bonne cause, et plus tout le monde est à bord, plus vite les bénéfices se produiront.

Après avoir examiné un peu Gensym G2, il semble que la façon d'aborder ce problème dépendra fortement de la quantité de code de base qui ressemble à ceci :

Dans le cas de ce dernier, vous travaillez avec un code source qui est effectivement une quantité connue et certaines des autres réponses offrent des conseils très judicieux pour y faire face.

Si la majeure partie de la base de code est cette dernière, ou même si une partie importante l'est, vous allez rencontrer le problème intéressant d'avoir du code qui ne peut probablement pas être refactorisé en raison de son extrême spécialisation, ou pire encore, il peut être amovible, mais à moins qu'il ne soit correctement documenté, vous ne savez pas si vous supprimez du code critique (pensez à quelque chose comme une opération scram) qui ne semble pas être le cas à première vue.

Bien qu'évidemment votre première priorité soit d'obtenir une sorte de contrôle de version en ligne, comme l'a souligné ElYusubov, et il semble que le contrôle de version soit pris en charge depuis la version 8.3. Étant donné que G2 est une combinaison de plusieurs méthodologies linguistiques différentes, vous trouverez probablement qu'il est plus efficace d'utiliser le contrôle de version qui l'accompagne plutôt que d'essayer de trouver autre chose et de le faire fonctionner.

Ensuite, bien que certains préconisent probablement de commencer à refactoriser, je suis un ardent défenseur de s'assurer que vous comprenez parfaitement le système avec lequel vous travaillez avant de commencer à toucher le code, en particulier lorsqu'il s'agit de code et de diagrammes visuels développés par développeurs sans formation formelle (ou expérience) en méthodologies de génie logiciel. Le raisonnement pour cela est multiple, mais la raison la plus évidente est que vous travaillez avec une application qui a potentiellement plus de 100 années-personnes de travail et que vous devez vraiment vous assurer que vous savez ce qu'elle fait et combien la documentation qu'il contient. Comme vous n'avez pas dit dans quelle industrie le système est déployé, sur la base de ce que j'ai lu à propos de G2, il semble qu'il soit prudent de supposer qu'il s'agit probablement d'une application critique pour la mission qui peut même avoir un potentiel d'avoir également des implications pour la sécurité des personnes . Ainsi, comprendre exactement ce qu'il fait sera très important. S'il y a du code qui n'est pas documenté, travaillez avec les autres membres de l'équipe pour vous assurer que la documentation est mise en place pour s'assurer que les gens peuvent déterminer ce que fait le code.

Ensuite, commencez à encapsuler les tests unitaires autour d'autant de base de code et de diagrammes visuels que vous le pouvez. Je dois admettre que je ne sais pas trop comment procéder avec G2, mais cela pourrait presque valoir la peine de créer votre propre cadre de test pour le mettre en place. C'est également le moment idéal pour commencer à présenter les autres membres de l'équipe afin de les familiariser avec certaines des pratiques d'ingénierie les plus rigoureuses impliquées dans la qualité du code (c'est-à-dire que tout le code doit avoir des tests unitaires et une documentation).

Une fois que vous avez mis en place des tests unitaires sur une bonne partie du code, vous pouvez commencer à aborder le refactoring d'une manière telle que celle suggérée par haylem, cependant, n'oubliez pas de garder à l'esprit que vous avez affaire à quelque chose qui est destiné au développement de systèmes experts et au refactoring. cela pourrait être une bataille difficile. C'est en fait un environnement où il y a quelque chose à dire pour ne pas écrire du code extrêmement générique parfois.

Enfin, assurez-vous de prêter une attention particulière à ce que disent les autres membres de l'équipe, juste parce que la qualité du code et du diagramme n'est pas la meilleure ne les reflète pas nécessairement mal. En fin de compte, pour le moment, ils sont susceptibles d'en savoir plus sur ce que fait l'application que vous, c'est pourquoi il est d'autant plus important que vous vous asseyiez et que vous compreniez ce qu'elle fait avant d'apporter également des modifications radicales.

Habituellement, les plaintes que vous entendez au départ n'ont rien à voir avec les problèmes importants. Après tout, il est tout à fait normal d'entendre ces plaintes dans n'importe quel projet logiciel.

Code difficile à comprendre ? Vérifier. Base de code massive ? Vérifier.

Le vrai problème est que les gens partent, et quand la nouvelle personne rejoint l'organisation, il y a une désorientation typique. En outre, il existe un problème d'attentes irréalistes et de problèmes de qualité du code.

Voici ce que je voudrais aborder, dans l'ordre :

  1. Sauvegardes, à la fois le serveur et la version locale
  2. Configurer le suivi des bogues
  3. Mettre en place un système de gestion de versions
  4. Configurer la FAQ/Wiki
  5. Premier débriefing de tous les scientifiques/programmeurs
    • Rappelez-leur la règle des 80/20. 20% des bugs sont responsables de 80% des problèmes.
    • Concentrez-vous sur les problèmes les plus importants et gardez les demandes d'amélioration, etc.
    • Le but ici n'est pas d'effrayer les gens avec une grande liste, mais une liste de petites victoires réalisables. Après tout, vous devez également prouver votre valeur.
  6. Mettre en place un système de build
    • Commencez à travailler pour obtenir des versions fiables (cela peut prendre un certain temps)
    • identifier et nommer chaque projet
    • identifier les dépendances cycliques
    • s'il existe des binaires de certains projets open source, essayez d'obtenir des sources
  7. Identifier comment le code G2 peut être modularisé, par ex. API, services
  8. Identifier comment le code G2 peut être testé, documenté.
  9. Mettre en place un système de révision de code
  10. Deuxième débriefing
    • A quoi ressemble un module idéal ?
    • Comment boucler l'ancien code
    • Comment encapsuler un nouveau module autour de l'ancien code (voir le modèle Strangler http://agilefromthegroundup.blogspot.com.au/2011/03/strangulation-pattern-of-choice-for.html )
  11. Identifiez une équipe de crack de meilleurs programmeurs et travaillez avec eux pour envelopper leurs modules.
  12. Les revues de code sont là à ce stade pour améliorer la communication et la documentation. Gardez-le facile à ce stade. Triez les problèmes de processus.
  13. Déployez le système auprès d'autres programmeurs. Laissez les membres de l'équipe d'élite devenir des mentors pour les autres. N'oubliez pas que la mise à l'échelle est le problème ici. Vous êtes effectivement dans un rôle de gestion.

Des questions comme celles-ci sont la raison d'être du projet Software Carpentry.

Depuis 14 ans, nous enseignons aux scientifiques et aux ingénieurs les compétences de base du développement logiciel : contrôle de version, tests, modularisation du code, etc. Tous nos documents sont disponibles gratuitement sous une licence Creative Commons, et nous organisons chaque année une vingtaine d'ateliers gratuits de deux jours pour aider les gens à démarrer.

Sur cette base, je pense que le meilleur point de départ est probablement l'excellent (court) livre de Robert Glass Faits et erreurs du génie logiciel: son approche fondée sur des preuves est un bon moyen de convaincre les scientifiques que ce que nous leur disons sur les bonnes pratiques de programmation est plus qu'une simple opinion.
En ce qui concerne les pratiques spécifiques, les deux que les gens sont le plus disposés à adopter sont le contrôle de version et les tests unitaires une fois ceux-ci en place, ils peuvent s'attaquer au type de refactorisation systématique que Michael Feathers décrit dans Travailler efficacement avec le code hérité.
je ne recommande plus Le programmeur pragmatique (beaucoup d'exhortation, difficile à mettre en pratique pour les novices), et je pense que McConnell Code terminé c'est trop pour commencer (même si c'est une bonne chose de leur donner six mois ou un an, une fois qu'ils ont maîtrisé les bases).

Je recommande également fortement l'excellent article de Paul Dubois "Maintenir l'exactitude dans les programmes scientifiques" (L'informatique dans les sciences et l'ingénierie, mai-juin 2005), qui décrit une approche de « défense en profondeur » qui combine une dizaine de pratiques différentes de manière logique et cohérente.

Je pense que vous devez d'abord clarifier votre situation. Que veulent-ils de toi ?

  • Il est très peu probable qu'ils veuillent que vous appreniez une langue ancienne, car cela semble maintenant une impasse : il y a de moins en moins de chances de trouver quelqu'un connaissant ou souhaitant apprendre G2, de sorte que les connaissances seront enfouies dans le tas de code qui s'effondre lorsque les scientifiques actuels partent ou le code entièrement corrigé échoue de plus en plus souvent.
  • Les scientifiques (ou certains d'entre eux) sont-ils prêts à apprendre un nouveau langage et de nombreux paradigmes de programmation ? Ou veulent-ils séparer la programmation et l'activité scientifique à long terme, et peut-être avoir plus de programmeurs si nécessaire ? Cela semble une séparation rationnelle et plus efficace des compétences.

Je pense que l'exigence de base ici est de "enregistrer les connaissances dans le système", vous devez donc aller les fouiller !

La première tâche consiste à rédiger une documentation.

Analysez la structure et les exigences comme s'il s'agissait d'une nouvelle tâche, mais à l'aide d'un système existant. Ils seront ravis parce que vous DEMANDEZ d'abord au lieu d'ENSEIGNER - et vous obtiendrez rapidement des connaissances de base suffisantes, mais plus organisées du point de vue d'un programmeur : « que se passe-t-il ici ? » La documentation (structure statique du système, workflow, composants, problèmes) leur sera immédiatement utile et leur montrera peut-être des informations plus pertinentes qu'à vous (certains gars peuvent avoir "AHA!" et commencer à corriger certains codes immédiatement ).

Vous devriez alors commencer à demander où ils veulent aller ?

S'ils sont prêts à s'éloigner du G2, quel système veulent-ils voir (plate-forme, langage, interface, structure générale) ? Vous pouvez commencer à écrire un wrapper externe autour du système si possible, ayant la structure cible, mais conservant les composants d'origine, commençant ainsi lentement une sorte de framework qui permet à de nouveaux composants d'être implémentés dans cet environnement cible. Vous devez trouver les services de base (connexions de données persistantes et "boîtes à outils": calcul de base, dessin, bibliothèques .), et ainsi leur fournir un environnement familier dans une nouvelle plate-forme et un nouveau langage, ce qui permet la transition soit par vous, soit par eux : prendre les anciens codes un par un, les réimplémenter (et les NETTOYER !) dans le nouvel environnement. Lorsque cela est prêt, ils connaissent la nouvelle langue et la couche de service (principalement créée par vous, désolé) est prête à héberger les nouveaux composants.

S'ils ne bougent pas, vous devez apprendre G2, et y créer le cadre modulaire, dans lequel vous ou ils doivent déplacer les composants (avec nettoyage). Quoi qu'il en soit, le langage n'est qu'une sérialisation de données et d'un arbre d'algorithmes.

Lors de l'analyse et de la rédaction des docs, lisez, utilisez et faites la publicité des modèles GoF Design ! :-)

Je viens de terminer une série de présentations sur les principes SOLID de Robert Martin pour mes collègues. Je ne sais pas dans quelle mesure ces principes se traduisent en G2, mais puisque vous recherchez 5 à 7 fondamentaux de base, ceux-ci semblent être un ensemble bien établi pour commencer. Si vous voulez l'arrondir à 7, vous pouvez commencer par DRY et ajouter Fail-Fast.

Le seul problème de production ressemble à un problème de gestion du changement. Si tel est le cas et que le logiciel le fait autrement, le premier conseil que je donnerais est de résister à l'envie d'en faire trop et trop vite.

Le contrôle de la source, la refactorisation, des développeurs plus entraînés sont tous de bonnes suggestions, mais si c'est la première fois que vous avez à faire face à ce genre de problème, avancer lentement et apporter des modifications contrôlées ne peut pas être suffisamment souligné.

L'envie de déchiqueter le gâchis sera parfois grande, mais jusqu'à ce que vous en ayez suffisamment fait l'ingénierie inverse pour savoir que vous pouvez tester votre version de remplacement de manière adéquate, vous devez être très prudent.

Les principes les plus importants pour travailler dans une telle situation sont :

Être patient. Un trou qui a mis 20 ans à creuser ne sera pas comblé en quelques semaines.

Sois positif. Résistez à la tentation de vous plaindre et de vous plaindre.

Soyez pragmatique. Regardez un changement positif que vous pouvez accomplir en une journée et faites-le aujourd'hui. Vous avez déjà un système de contrôle de version ? Mettre en œuvre et former les gens. Ensuite, regardez et voyez si vous pouvez automatiser les tests (tests unitaires ou quelque chose de similaire). Rincer. Répéter.

Soyez un modèle. Montrez (ne vous contentez pas de dire) aux gens comment l'agilité fonctionne en étant agile. Les trois premiers points ci-dessus sont les clés pour être un bon gars, qui est le prédécesseur d'être un gars agile efficace. À mon avis, les gens qui sont des développeurs admirables ne sont pas seulement intelligents, ils sont aussi de bons employés et collègues modèles.

Cartographiez votre territoire. J'ai une technique pour cartographier les bases de code héritées géantes. Je clone le référentiel, crée une copie de travail, puis j'essaie de changer quelque chose et de voir ce qui ne fonctionne pas. En enquêtant sur le couplage (via l'état global, ou des API cassées, ou un manque d'API cohérente ou d'abstractions ou d'interfaces contre lesquelles programmer) et en lisant le code qui se brise lorsque je change les choses, je découvre le casse-tête, je pose des questions qui mènent à les idées du reste de l'équipe (Oh, nous avons ajouté que parce que Boss X il y a 5 ans l'avait exigé, cela n'a jamais fonctionné !). Au fil du temps, vous obtiendrez une carte mentale du territoire. Une fois que vous saurez quelle est sa taille, vous en saurez assez pour faire votre carte et rentrer chez vous. Encouragez les autres à cartographier le territoire de votre base de code géante et à développer les connaissances techniques de l'équipe. Certaines personnes rechignent à la "documentation" parce qu'elle n'est pas agile. Peu importe. Je travaille aussi dans des environnements scientifiques, et la documentation est reine pour moi, au diable les manifestes agiles.

Créez de petites applications. Lorsque je travaille avec une base de code héritée, je trouve que je suis réduit à néant. Je retrouve mon esprit en créant de petites applications d'aide. Peut-être que ces applications vont vous aider à lire, comprendre et modifier cette base de code G2 géante. Vous pouvez peut-être créer un mini IDE ou un outil d'analyse qui vous aidera à travailler dans votre environnement. Il existe de nombreux cas où la méta-programmation et la création d'outils vous aideront non seulement à sortir des impasses géantes que les bases de code héritées vous imposent, mais elles donneront également à votre cerveau la capacité de voler sans restriction par votre langage G2. Écrivez vos outils et assistants dans le langage dans lequel vous pouvez les faire le plus rapidement et le mieux. Pour moi, ces langages incluent Python et Delphi. Si vous êtes un gars de Perl, ou que vous AIMEZ réellement programmer en C++ ou C#, alors écrivez vos outils d'aide dans ce langage. apprenez au reste de l'équipe à créer de petites applications et outils d'assistance, et des "composants" et vous finirez par voir que votre base de code héritée n'est pas si intimidante après tout.

Contrôle de révision: montrer aux experts du domaine l'avantage de pouvoir revenir en arrière, voir qui a changé quoi, etc. (C'est plus difficile avec les fichiers tout binaires, mais si le contenu est bien du code, il existe sûrement une sorte de convertisseur G2 en texte qui peut activer les différences.)

Intégration continue et test : impliquez les experts du domaine dans la création de tests de bout en bout (plus facile, car ils doivent déjà avoir des entrées et des sorties attendues quelque part) et de petits tests unitaires (plus difficiles, car le code spaghetti implique probablement de nombreuses variables globales) qui couvrent presque toutes les fonctionnalités et des cas d'utilisation.

Refactoriser le code commun en routines et composants réutilisables. Les non-logiciels sans contrôle de révision copient et collent probablement des centaines de lignes à la fois pour créer des routines. Trouvez-les et refactorisez-les, montrant que tous les tests réussissent et que le code est devenu plus court. Cela vous aidera également à apprendre son architecture. Si vous avez de la chance au moment où vous devez commencer à prendre des décisions architecturales difficiles, vous pourriez être à 100KLOC.

Politiquement, si vous rencontrez une résistance de la part des anciens dans ce processus, engagez un consultant pour qu'il vous donne une conférence sur la bonne méthodologie logicielle. Assurez-vous d'en trouver un bon dont vous êtes d'accord avec les points de vue et faites en sorte que la direction accepte la nécessité du consultant même si les experts du domaine ne le font pas. (Ils devraient être d'accord - après tout, ils vous ont embauché, donc ils se rendent évidemment compte qu'ils ont besoin d'une expertise en génie logiciel.) C'est bien sûr une astuce pour gaspiller de l'argent, mais la raison en est que si vous - le nouveau jeune programmeur de pointe - dites eux, ils ont besoin de faire quelque chose, ils peuvent l'ignorer. Mais si la direction paie 5 000 $ à un consultant pour qu'il vienne lui dire ce qu'il doit faire, il lui fera davantage confiance. Points bonus: demandez au consultant de conseiller deux fois plus de changements que vous le souhaitez vraiment, alors vous pouvez être le "bon gars" et vous ranger du côté des experts du domaine, en faisant le compromis de ne changer que la moitié de ce que le consultant a suggéré.

« Le programme lui-même est un modèle physique d'une usine de traitement chimique complexe.

"Puisque G2 est comme du non-code, mais plutôt du code automatisé écrit par une interface graphique gadawful. " - Erik Reppen

En supposant que l'objectif principal de votre logiciel est de simuler (peut-être optimiser, exécuter des estimations de paramètres sur) un complexe usine chimique, ou des parties d'une. alors je voudrais lancer une suggestion assez différente:

Vous feriez peut-être bien d'envisager d'utiliser un langage de modélisation mathématique de haut niveau pour extraire l'essence, les modèles mathématiques de base, hors de logiciel codé à la main.

Ce que fait un langage de modélisation, c'est de découpler la description du problème des algorithmes utilisés pour résoudre le problème. Ces algorithmes sont généralement applicables à la plupart des simulations/optimisations d'une classe donnée (par exemple, les processus chimiques), auquel cas ils ne devraient vraiment pas être réinventés et maintenus en interne.

Trois progiciels commerciaux largement utilisés dans votre industrie sont : gPROMS, Aspen Custom Modeller et (si vos modèles n'incluent pas de phénomènes répartis dans des domaines spatiaux), il existe des progiciels basés sur Modelica, tels que Dymola.

Tous ces packages prennent en charge les "extensions" d'une manière ou d'une autre, de sorte que si vous avez des parties de vos modèles qui nécessitent une programmation personnalisée, elles peuvent être encapsulées dans un objet (par exemple un .DLL) qui peut être référencé par les équations dans le maquette. Pendant ce temps, l'essentiel de votre modèle reste succinct, décrit sous une forme facilement lisible par les scientifiques directement. C'est une bien meilleure façon de capturer les connaissances et la propriété intellectuelle de votre entreprise.

La plupart de ces programmes devraient également vous permettre de « démarrer petit » et de porter de petites parties (sous-modèles) de votre code monolithique dans leur format, en étant appelés en externe. Cela peut être un bon moyen de maintenir un système fonctionnel et de le valider une pièce à la fois.

Avis de non-responsabilité : j'ai travaillé comme ingénieur logiciel dans l'entreprise derrière gPROMS pendant 8 ans. À cette époque, j'ai vu (et parfois incorporé) des exemples de logiciels personnalisés (venant par exemple du milieu universitaire) qui avaient commencé petit et bien rangé, mettant en œuvre une solution ou un algorithme intelligent, mais ont ensuite explosé au fil des ans avec des extensions et des modifications - sans les conseils utiles de un ingénieur logiciel pour le garder propre. (Je suis un grand fan des équipes multidisciplinaires.)

Je peux donc dire avec une certaine expérience que certains choix clés mal faits au début du développement d'un logiciel (comme un langage ou une bibliothèque de clés) ont tendance à rester et à causer de la douleur pendant longtemps. Ils ont déjà « façonné » le logiciel autour d'eux. Il me semble que vous pourriez être confronté à de nombreuses années de pur nettoyage de code ici. (J'hésite à utiliser des nombres, mais je pense à plus de 10 années-personnes, peut-être beaucoup plus si vous ne pouvez pas transférer le code de G2 vers quelque chose qui prend en charge de bons outils de refactorisation automatisés comme Eclipse/Java quick-smart.)

Bien que mon statut par défaut soit "refactoriser et conserver un système fonctionnel", je pense également qu'une fois qu'un problème devient "trop ​​important", un changement/réécriture plus radical devient globalement plus rapide. (Et apporte peut-être des avantages supplémentaires, comme le passage à une technologie plus moderne.) Je dis cela avec une certaine expérience du portage sur une nouvelle plate-forme logicielle, mais d'après ce que je comprends, c'est encore plus dramatique avec un portage vers un package de modélisation mathématique.

Pour donner un peu de perspective, vous pourriez être assez étonné de la réduction de la taille. Par exemple. les 200 000 LoC pourraient en fait être représentés dans quelque chose comme 5 000 lignes d'équations (OK, je suppose ici, mais je pourrais essayer de vous obtenir un témoignage réel d'amis dans l'entreprise) plus quelques modules de fonction relativement petits écrits dans quelque chose comme C (par exemple, des calculs de propriété physique - bien que, encore une fois, des emballages standard puissent exister en fonction de votre procédé chimique). C'est parce que vous jetez littéralement le code de la solution algorithmique et laissez une « pile » de solveurs mathématiques à usage général faire le travail difficile. Une fois que les simulations sont en cours d'exécution, vous pouvez faire bien plus avec elles, comme optimiser le processus - sans changer une ligne de code.

Enfin, je dirais : si la seule documentation fiable des divers modèles mathématiques (et algorithmes) est le code lui-même, vous aurez besoin de l'aide des scientifiques et des auteurs originaux pour extraire ces modèles, dès que possible, et non des années plus tard lorsque certains d'entre eux sont peut-être passés à autre chose. Ils devraient trouver qu'un langage de modélisation mathématique est un moyen très naturel de capturer ces modèles - ils peuvent même (choquer l'horreur) prendre plaisir à le (ré)écrire.

Enfin, comme ma réponse est peut-être erronée, je voudrais juste ajouter un livre de plus à la liste des bons livres déjà référencés ici : Clean Code de Robert Martin. Plein de conseils simples (et justifiés) qui sont faciles à apprendre et à appliquer, mais qui pourraient faire toute la différence pour les personnes qui développent un nouveau code dans votre entreprise.


Voir la vidéo: #2 - GDAL Installation for Python (Octobre 2021).