| Lautsprecher |
Transkript |
| Serkay Olmez |
Hallo, hier sind Serkay und Fred von Seagate und heute werden wir darüber sprechen, wie wir ein JSL-Ökosystem zum Verwalten unserer JSL-Skripte erstellt haben. |
| |
Wir verwenden Git, um die Quellcodeverwaltungen und den Quellcode unserer JSL-Skripte zu verwalten und sie zu verteilen. Das wird der Hauptpunkt des heutigen Vortrags sein. |
| |
Darüber hinaus werde ich aber auch über VBA für die PowerPoint-Integration sowie die Erfassung von Absturzprotokollen und Unit-Tests sprechen. Ich werde gleich zur Gliederung springen. |
| |
Ich möchte zunächst über unsere Geschichte mit JSL sprechen. Ich schreibe seit etwa 10 Jahren Skripte in JSL. |
| |
Und wir sind sehr zufrieden mit dem, was wir jetzt erreicht haben, aber es hat eine ganze Weile gedauert, bis wir hierher gekommen sind, und ich möchte über die Meilensteine unserer Erfahrung sprechen, darüber, was wir bisher getan haben und warum wir das getan haben. |
| |
Und dann sprechen wir über Git und wie wir Git für die Quellcodeverwaltung unserer JSL-Skripte aktiviert haben und wie es uns ermöglicht hat, weitere Funktionen zu entwickeln. Wenn Sie beispielsweise Git aktivieren, |
| |
Sie können weitere Funktionen hinzufügen, z. B. die Überwachung Ihrer Skripte. So wissen Sie, dass die Entwickler wissen, dass ihre Skripte verwendet werden, und können die Verwendung überwachen. |
| |
Und was wahrscheinlich noch wichtiger ist: Sie können auch Protokolle sammeln. Wenn das Skript abstürzt, weiß der Entwickler Bescheid und kann die Fehler beheben. Und Sie können … |
| |
Sie können noch eine weitere Funktion hinzufügen, die noch einen Schritt weiter geht. Sie können sogar automatisierte Bug-Tickets erstellen, wenn Sie bereits wissen, dass Ihr Skript abgestürzt ist. So können Sie automatisch ein Bug-Ticket dafür erstellen. Und Sie können diese Tickets mit einer Tracking-Software wie JIRA oder Atlassian verfolgen. |
| |
Abschließend werde ich unsere bisher besten Vorgehensweisen und gewonnenen Erkenntnisse darlegen. |
| |
Also, |
| |
Und im Anhang habe ich auch eine Anleitung für ein Skript, über das ich sprechen werde. Es ist ein Skript, mit dem man Bilder nach PowerPoint übertragen kann. |
| |
Und ich habe ein sehr ausführliches Handbuch dafür, und ich sollte Sie nur wissen lassen, dass alles, worüber ich hier spreche, die Daten und die Skripte verfügbar sein werden. |
| |
Sie sind in einem öffentlichen Repository im Abschnitt „Referenzen“ hier veröffentlicht. Sie können diese Dateien einfach dort herunterladen, wenn Sie möchten. Lassen Sie mich also beginnen mit |
| |
mit der kurzen Geschichte hier. Also 10...Ich arbeite seit ungefähr 10 Jahren mit JSL und begann, ich begann mit |
| |
sehr grundlegend und ich wusste nicht wirklich viel über JSL-Skripting. |
| |
Und wenn Sie dann damit beginnen, wird Ihnen klar, dass Sie eine ordnungsgemäße Quellcodeverwaltung und geeignete Möglichkeiten zur Verteilung Ihrer Skripte benötigen. |
| |
Das Besondere an JMP-Skripting ist, dass es keinerlei Einstiegshürden gibt. Sie können also buchstäblich manuell einen Plot erstellen und dann das Skript abrufen. Es ist für Sie geschrieben. |
| |
Und Sie können auch die Community to JMP in JMP.com verwenden, um Fragen zu stellen und Antworten zu erhalten. |
| |
Und Sie... das Skripting ist so effizient, dass Sie Ihre Arbeit so effizient erledigen, dass die Leute es bemerken werden. Sie werden Sie fragen, wie Sie die Dinge machen, und Sie werden sagen: „Ich habe ein Skript dafür.“ Und sie werden |
| |
fragen Sie: „Können Sie mir das mitteilen?“ Und plötzlich werden Sie zum Entwickler, obwohl Sie das nicht beabsichtigt hatten. |
| |
Und dann müssen Sie sich mit der Verteilung Ihrer Skripte befassen. Die erste Idee, die mir in den Sinn kommt, ist, sie einfach anzuhängen, was eine schreckliche Idee ist, und ich habe das eine ganze Weile lang getan. |
| |
Und es ist ziemlich offensichtlich, warum das keine gute Idee ist, denn Sie hängen ein Skript an und senden es dann aus und am nächsten Tag machen Sie ein |
| |
Revision und dann müssen Sie es erneut senden, und Sie wissen nicht einmal, ob der Benutzer sich für die nächste entscheidet. Ich veranschauliche den Punkt hier also nur. |
| |
Kürzlich erhielt ich eine E-Mail von einem Kollegen und er bezog sich auf ein Skript, das ich 2017 erstellt hatte und ich nummerierte meine Skripte einfach mit diesen |
| |
Versionsnummern, was keine gute Idee ist. Nach drei, vier Jahren kommt es also zurück und man merkt, dass die Leute immer noch drei Jahre alte Skripte verwenden, weil sie nicht aktualisiert wurden. |
| |
Eine Möglichkeit, dieses Problem zu lösen, besteht darin, freigegebene Laufwerke zu verwenden. Basierend auf der Interaktion, die ich mit Leuten in ihnen hatte, in der |
| |
Discovery Summits, ist, dass viele Menschen, viele Unternehmen diese nutzen. Was Entwickler also tun, ist, |
| |
Speichern Sie Ihre Skripte auf einem freigegebenen Laufwerk, und die Benutzer ziehen direkt von diesem Laufwerk. Dies löst zwar die Hälfte des Verteilungsproblems, ändert aber nichts an der Quellcodeverwaltung. Sie können die Änderungen, die Sie am Code vorgenommen haben, nicht nachvollziehen. |
| |
Und deshalb sind wir tatsächlich auf Git umgestiegen. Das war ein Durchbruch für uns und hat viele Funktionen ermöglicht. Was man also mit Git macht, ist, dass Entwickler ihre Skripte in ein Repository pushen und |
| |
Benutzer werden ihre Skripte direkt aus Git ziehen. Das war eine große Verbesserung für uns und ermöglichte es uns, Absturzprotokolle zu sammeln und |
| |
Verwendung der Skripte usw. Und ich möchte noch ein paar Dinge erwähnen, die ich auf den Summits gelernt habe. Sie waren sehr nützlich, um meine Skriptkenntnisse zu verbessern, und ich habe 2018 an einem Summit teilgenommen und einiges über Ausdrücke usw. gelernt. Also |
| |
Die Leute möchten sich diese Präsentationen vielleicht noch einmal anhören, weil sie ihnen beim Skripting helfen. |
| |
Ein weiterer Meilenstein für uns war das Testen. Inspiriert wurde ich von einem Vortrag auf dem Summit im letzten Jahr, in dem es um Unit-Tests ging, mit denen Sie Ihre Skripte vor der Veröffentlichung automatisch testen können. |
| |
Heute werde ich hauptsächlich über Integrationstests sprechen, da Unit-Tests … Unit-Tests sind erforderlich, aber nicht ausreichend. |
| |
Mit einem Unit-Test können Sie alle Module testen, und sie funktionieren einwandfrei. Wenn Sie sie jedoch zusammenfügen, funktionieren sie nicht. Sie stürzen ab, wie hier dargestellt. Wahrscheinlich wird jede Schublade getestet, aber wenn Sie sie zusammenfügen, funktionieren sie nicht. |
| |
Eine nette Funktion, die dem Entwickler sehr hilft, ist die Protokollsammlung. |
| |
Es ist sehr hilfreich zu wissen, dass Ihr Skript abgestürzt ist und wie es dazu kam. Dies können Sie tun, indem Sie die Protokolle der Benutzer sammeln. Sie können dann zurückgehen und Ihr Skript reparieren und die Änderungen übertragen. Die Benutzer erhalten dann sofort ihr korrigiertes Skript. |
| |
Und die letzte Funktion, die wir kürzlich eingeführt haben, ist die automatisierte Fehlerberichterstattung. Da Sie bereits den Absturzbericht haben, warum nicht auf diese Informationen reagieren? Und so erstellen wir eine automatisierte |
| |
Überwachung |
| |
System, das die Absturzprotokolle verfolgt und automatisch Fehlerberichte erstellt, damit der Entwickler daran arbeiten kann. Darüber hinaus können Sie den Benutzer als Beobachter hinzufügen, damit er weiß, dass jemand an dem Problem arbeitet. Das löst das Problem |
| |
das die Informationslücke zwischen Benutzer und Entwickler schließt. |
| |
Dies zeigt die Zeitleiste und ich werde einige Zeit damit verbringen, |
| |
zu den einzelnen Elementen, aber wir beginnen mit Git und ich werde dies schnell erstellen und Fred darüber sprechen lassen. |
| 163084 |
Okay. |
| |
Also, |
| |
Git ist lediglich ein Versionskontrollsystem, und ich verwende das Wort Versionskontrolle nicht. Eigentlich möchte ich sagen, dass Git Ihnen praktisch unbegrenzte Wiederholungsmöglichkeiten bietet, selbst wenn Sie Git nur auf Ihrem lokalen Computer verwenden. Es |
| |
ermöglicht Ihnen, die Revisionen Ihrer Dateien zu verfolgen und zu alten Dateien zurückzukehren, falls Sie feststellen, dass Ihre Arbeit der letzten Wochen fehlerhaft war und Sie zu etwas von vor mehreren Wochen zurückkehren möchten. |
| |
Git ist also lediglich eine Software, die Sie auf Ihrem lokalen Computer installieren. Sie erstellt ein Repository, und dieses Repository kann dann in andere Repositorys hochgeladen werden. |
| |
Wie GitLab oder GitHub. TortoiseGit ist eine GUI-Oberfläche, die Sie auf Ihrem lokalen Rechner nutzen können und die die Arbeit vereinfacht. Also, Serkay, könnten Sie bitte die nächste Folie öffnen. |
| |
Das Modell, das ich Entwicklern zur Nutzung nahegebracht habe, befindet sich auf ihrem lokalen Computer. Die Entwickler auf dem lokalen Computer müssen den Git-Client installieren und starten |
| |
Versionskontrolle der Dateien auf ihrem lokalen PC. Sobald sie sich daran gewöhnt haben, können wir sie mit einem Remote-Repository verbinden |
| |
und Git verbindet sich mit Remote-Repositorys oder SSH im Allgemeinen oder anderen Methoden und sie können pushen |
| |
Kopien ihrer Git-Datenbank in das Remote-Repository. Sobald es im Remote-Repository ist, steht es einem HTTP-Webserver zur Verfügung, um es wieder freizugeben, und JMP |
| |
kann dann auf die URLs und den HTTP...HTTP-Webserver verweisen und Skripte von dort laden. Anstatt also ein freigegebenes Laufwerk zu verwenden, verwenden wir einen HTTP-Webserver, der durch einen Push in ein Git-Repository gefüllt wurde. |
| |
Und die Aufzählungspunkte weiter unten zeigen dann einfach die Vorteile und die genaue Funktionsweise auf. |
| |
Wir können zur nächsten Folie gehen. |
| Serkay Olmez |
Also, Fred, ich übernehme hier und zeige Ihnen … eine sehr einfache Illustrationsimplementierung. Die Skripte sind in den Referenzen verfügbar. |
| |
Also, |
| |
Dies ist ein sehr einfacher Code. Und was ich hier zeige, ist der Code, den der Entwickler entwickelt. Es ist das absolute Minimum, richtig. Es ist nur ein Dialogfeld mit der Meldung „Hallo Welt“. |
| |
Und angenommen, der Entwickler möchte diesen Code an die Benutzer weitergeben. Anstatt diesen Code weiterzugeben, gibt der Entwickler diesen Code weiter: |
| |
Dies ist ein Link zum Repository. Dies ist also das Repository zum dort gespeicherten Hello-JSL-Skript ... |
| |
im Remote-Repository. Der Benutzer greift einfach... der Benutzer greift die |
| |
Skript aus der URL. Es handelt sich also um statischen Code. Er muss nicht geändert werden, sodass der Entwickler das Skript jederzeit ändern kann, ohne dass der Benutzer etwas tun muss. Ich zeige Ihnen hier nur eine Illustration und möchte nur zum Vollbild wechseln. |
| |
Es veranschaulicht nur, wie das Ganze mit einer bestimmten GUI funktioniert, nämlich GitHub Desktop. Sie installieren also Folgendes |
| |
Software auf Ihrem Computer und erstellen Sie ein lokales Repository, und sie werden die Änderungen, die Sie vorgenommen haben, protokollieren. In diesem Fall habe ich zum Beispiel gerade dieses Hallo-JSL-Skript erstellt |
| |
Die Software erkennt die Änderung und hebt sie automatisch hervor. Zuerst müssen Sie die Änderung in Ihr lokales Repository übertragen. |
| |
Dadurch werden diese Dinge in Ihr lokales Repository übertragen und dann zum Ursprung, einem Remote-Repository, übertragen. Jetzt werde ich es zum Remote-Repository übertragen, wodurch es den Benutzern zur Verfügung steht. |
| |
Sobald Sie das getan haben, können die Benutzer den neuen Code abrufen. Ich wechsle jetzt zurück zur Benutzerrolle. Das Skript wird ausgeführt. Sobald Sie das getan haben, wird das Dialogfeld angezeigt. Sie führen also das Skript aus, das Sie aus dem Repository abgerufen haben. |
| |
Ich werde dies also anhand eines fortgeschritteneren Codes, der auch mit PowerPoint zusammenhängt, etwas besser veranschaulichen. |
| |
Viele Leute führen viele Analysen in JMP durch und möchten ihre Ergebnisse am Ende des Tages trotzdem in PowerPoint übertragen. Ich weiß, dass JMP einige Funktionen bietet, um |
| |
Bilder direkt in PowerPoint, aber wir wollten etwas mehr... etwas etwas anspruchsvolleres. Wir wollen |
| |
Verwalten Sie die Vorlage der PowerPoint. Wir möchten noch einige Dinge in der PowerPoint-Präsentation tun, entscheiden, wie viele Bilder wir pro Folie einfügen möchten usw. Und |
| |
Um dies zu tun, müssen Sie zunächst JMP mit PowerPoint verbinden, und das ist tatsächlich sehr einfach ... |
| |
auf eine sehr gute Art und Weise, sodass Sie JMP nicht einmal verlassen müssen. Sie können also herausfinden, wo sich Ihre ausführbare PowerPoint-Datei befindet. Normalerweise befindet sie sich unter „Programme“. |
| |
Anschließend erstellen Sie eine Batchdatei, die diese PowerPoint-Programmdatei auslöst. Diese greift auf die gewünschte PowerPoint-Datei zu und führt sie aus. All dies können Sie in JMP erledigen. Im Wesentlichen sucht es nach der PowerPoint-Programmdatei. |
| |
Sobald es gefunden ist, wird es in dieser Batchdatei gebündelt. Außerdem enthält es den Pfad zur PowerPoint-Datei, die Sie ausführen möchten. |
| |
und das Makro und so wird die PowerPoint ein Makro enthalten, um die Verwaltung innerhalb der PowerPoint durchzuführen. So geht's |
| |
JMP mit PowerPoint verknüpfen, und dazu müssen Sie JMP sogar in PowerPoint verwenden. Die Frage ist jedoch, wie Sie diese PowerPoint-Datei überhaupt an Ihre Benutzer weitergeben. Sie könnten |
| |
Bitten Sie ihn, die Datei herunterzuladen. Das ist nicht ideal, da Sie dies automatisch verwalten und gleichzeitig die Quellcodeverwaltung für Ihre PowerPoint-Präsentation übernehmen möchten. Die Datei muss also gut geeignet sein und sich gut in das gesamte Ökosystem integrieren. Sie sollten sie nicht außerhalb des Systems platzieren. |
| |
Eine weitere Voraussetzung ist, dass Sie PowerPoint nicht bei jeder Ausführung des Skripts herunterladen möchten. Sie möchten PowerPoint also nur herunterladen, wenn sich im Bildrepository etwas geändert hat oder etwas Neues mit PowerPoint passiert. |
| |
Eine Möglichkeit hierfür ist die Verwendung dieses kleinen JMP-Skripts, eines JMP-Befehls, der das Erstellungsdatum angibt. Ich überprüfe hier |
| |
das Datum der lokalen Datei. Wenn die lokale PowerPoint-Datei älter ist als die im Repository, lade ich sie herunter. |
| |
Es wird die PowerPoint-Datei per HTTP-Anforderung herunterladen und |
| |
sieht ungefähr so aus. Sie müssen lediglich Ihre PowerPoint-Präsentation auf Ihrem lokalen Computer überprüfen. Falls sie nicht existiert, können Sie sie einfach per HTTP-Anfrage aus dem Repository abrufen. Falls sie existiert, sehen Sie sich das Datum an. Ist sie veraltet, rufen Sie sie einfach auf und |
| |
Ziehen Sie das Neue. Das Fazit ist also, dass Sie PowerPoint nahtlos in die JMP-Umgebung integrieren können, sodass Sie Ihre Ergebnisse, einschließlich Tabellen und Bilder, in JMP übertragen können. Und das alles, ohne die Quellcodeverwaltung zu beeinträchtigen. Ich werde hier eine Demonstration zeigen. |
| |
Dies ist beispielsweise der Code, den Sie Ihren Benutzern zur Verfügung stellen würden. Auch hier handelt es sich um statischen Code. Er enthält nichts außer einer URL, die das Skript mit dem Remote-Repository verknüpft. Es greift also auf die |
| |
JMP-Skript aus dem Repository und diese Skripte sind wieder verfügbar und Sie können sie einfach aus den Referenzen abrufen. |
| |
Von der Entwicklerseite aus gesehen ist dies das eigentliche Skript. Dies ist das Skript, das der Entwickler entwickelt hat und |
| |
er oder sie schiebt es in das Remote-Repository. Und das Schöne an diesem Skript ist, dass ich hier nur schnell auf ein paar Funktionen hinweisen möchte. |
| |
Schauen Sie sich zum Beispiel das hier an. Dies ist ein eigenständiges Textskript und Sie müssen keine PowerPoint-Dateien oder zusätzliche Skripte verteilen. |
| |
separat. Sie verknüpfen sie in Ihrem Skript und sie werden hier im Repository verknüpft. |
| |
einschließlich der PowerPoint-Präsentation. Dieses Skript verwaltet die gesamte Verteilung. Es holt sich die PowerPoint-Präsentation. |
| |
Bei Bedarf werden weitere Dateien abgerufen. Alles ist im Skript zusammengefasst, sodass die gesamte Verwaltung für Sie erledigt wird. Lassen Sie mich das kurz zeigen. Ich werde das zurückziehen |
| |
und schalten Sie es in den Vollbildmodus |
| |
so können Sie deutlich sehen. Dies ist also eine Demonstration der Auslösung von PowerPoint automatisch |
| |
für einen bestimmten Fall. Und was dieses Skript macht, ist, dass es die Pfade aus der Tabelle holt, dies ist eine JMP-Tabelle, die viele Bildpfade enthält, und diese beziehen sich auf dieses spezielle |
| |
Server, und es wird diese Pfade übernehmen und nur die hier hervorgehobenen nehmen und sie in PowerPoint einfügen. |
| |
Ich werde das einfach ausführen. Dieses Skript steht Ihnen zur Verfügung, wenn Sie es ausprobieren möchten. Es ist ein voll funktionsfähiges, nützliches Skript. Also, und ich führe das aus |
| |
Skript hier. Auch hier bezieht es sich auf das Repository. Es enthält also nicht das Zeilenskript, sondern zieht es einfach aus dem Repository. Sie führen es aus, es ruft den Code ab und führt einen Dialog aus. |
| |
Und ich werde das einfach ausführen. Ich werde nicht ins Detail gehen. Sobald Sie es ausführen, wird PowerPoint automatisch gestartet. |
| |
PowerPoint wird gestartet und dann werden die Folien erstellt. Es werden 20 Bilder geladen. Das dauert etwa 10 bis 20 Sekunden. Anschließend wird PowerPoint angezeigt. |
| |
fertig. Dies ist also die PowerPoint-Präsentation, die Sie erhalten. Alles wird automatisch erledigt und alles wurde aus dem Repository abgerufen. |
| |
Wie geht es weiter? Wie würden Sie diese PowerPoint-Präsentation überarbeiten? Ich nehme an, Sie möchten einige Änderungen an Ihrer Vorlage vornehmen. Und |
| |
Weitere Einzelheiten hierzu finden Sie im Anhang. Ich möchte Ihnen jedoch zeigen, wie Sie die |
| |
Skript in PowerPoint. Und ich gehe zum Vollbildmodus, |
| |
und ich werde das einfach ausführen. Wir beginnen mit dem, was wir auf der vorherigen Folie übrig gelassen haben, richtig, Sie hatten also diese Bilder. |
| |
Ich möchte die Vorlage auf einfache Weise ändern, um den Punkt zu veranschaulichen. Gehen Sie also zu ... |
| |
Sie gehen zum Makro, scrollen nach unten und finden die gewünschte Änderung. Ich werde hier eine einfache Änderung vornehmen. Ich ändere die Farbe der Kopfzeile, um das deutlich zu machen. Ändern Sie also Folgendes |
| |
Und |
| |
speichern. Und das geschieht in Echtzeit. |
| |
Sie speichern dies und können die Folien löschen, damit es schneller ins Repository gelangt, da Sie dies in das Repository pushen. |
| |
Und dann pushen Sie dies mit der Git-GUI. Es wird in das Repository verschoben |
| |
Und es wird Ihren Benutzern zur Verfügung gestellt. Alle Ihre Benutzer erhalten die Änderung sofort. Sie müssen sie also nicht bitten, PowerPoint oder ähnliches zu aktualisieren. |
| |
Dies geht nur in das Repository. |
| |
Und ich wechsle zurück zu JMP und in den Benutzermodus und führe dann das Skript erneut aus, wodurch die neue PowerPoint-Präsentation abgerufen wird. |
| |
Und wenn Sie es erneut ausführen, wird es durch die |
| |
Folien, es wird die Folie erstellt. Und was Sie bemerken werden, ist, dass Sie die Änderungen haben, bei denen es um die Änderung der Farbe der Kopfzeile ging. |
| |
Also, |
| |
was haben wir sonst noch? |
| |
Skriptüberwachung. Ich denke, das war eine der besten Funktionen, die wir entwickelt haben, denn sie gibt dem Entwickler die Möglichkeit zu sehen, ob |
| |
Ihr Skript... seins, sein Skript wird geschätzt oder nicht. Richtig. Wird es also ausgeführt? Wird es von jemandem regelmäßig ausgeführt? |
| |
Das ist ein Vorteil. Der andere Vorteil ist |
| |
Protokoll ... Absturzprotokollsammlung. Wenn das Skript fehlschlägt, können Sie den Fehler mithilfe der Protokollerfassungsfunktion von JMP erfassen. So binden Sie Ihre Unterprogramme in die Protokollerfassung ein. |
| |
Wenn es fehlschlägt... wird das Protokoll des Fehlers in diesem Protokolltext zurückgegeben. Und dann, was Sie auch tun, ist, dass Sie |
| |
Schließen Sie es in einen Versuch ein, damit das Skript für die Berichterstellung weiterhin verfügbar ist. |
| |
Und dann prüfen Sie, ob es leer ist. Wenn es leer ist, bedeutet das, dass es überhaupt keinen Absturz gab, Ihre Skripte also überlebt haben. |
| |
Wenn es jedoch nicht leer ist, bedeutet dies, dass es einen Absturz gab und Sie ihn eingedämmt haben. Sie können das Protokoll abrufen und es melden. Und dies funktioniert über HTTP |
| |
Benutzer-ID, der Skriptname und die Protokollnotiz, ob es sich um einen Absturz handelt ... |
| |
ob es sich um einen Absturz oder einen normalen Lauf handelte, vielleicht einige Leistungsmesswerte. Unterm Strich können Sie also einige Metadaten zu Ihrem Skript an den Entwickler zurücksenden. |
| |
Der Server protokolliert diese Daten und speichert sie, um sie zu überwachen. Ich zeige hier nur ein Beispiel. |
| |
Tabelle aus diesen. Es ist ein Absturzprotokoll, das...das den Datumsstempel hat, es hat einen Skriptnamen, also ist dieses Skript am Datum fehlgeschlagen |
| |
mit diesem speziellen Absturz. Das ist für den Entwickler äußerst nützlich, da er oder sie zurückgehen und das Problem beheben kann. Ich werde dies und das hier zusammenfassen und hier eine kurze Demonstration zeigen, die zeigt, wie man |
| |
wie du |
| |
den Absturz eindämmen und wie Sie ihn dem Benutzer melden. Ich werde hier also eine Subroutine zum Absturz bringen. Ich erstelle einen undefinierten Parameter |
| |
und JMP wird sich beschweren. Es wird sagen, dass dieses Ding nicht definiert ist, sodass das Skript abstürzt. Aber was ich tun werde, ist, dass ich diese Subroutine aufrufe |
| |
in einer Protokollerfassungsfunktion und alles wird unter try zusammengefasst. Obwohl das Skript mit der Subroutine abstürzte, wird es insgesamt überleben und in der Lage sein, einen |
| |
Absturzbericht. Geben Sie dem Benutzer eine schön formatierte Benachrichtigung und informieren Sie ihn darüber. Die Skripte stürzen mit diesem speziellen Fehler ab. Wir haben ein Protokoll dafür erstellt und arbeiten daran. Das ist also die Benachrichtigung, die Sie dem Benutzer geben. |
| |
Eine der wichtigsten Erkenntnisse, die ich bei den Summits gewonnen habe, war das automatisierte Testen. Früher habe ich meine Tests manuell durchgeführt, was sehr frustrierend ist. |
| |
Weil es Zeit kostet und Sie nicht jede einzelne Ecke Ihres Skripts erfassen können. Es ist unmöglich, stundenlange Tests durchzuführen, wenn Sie eine kleine Änderung vornehmen. |
| |
Ich begann mich mit automatisierten Tests zu beschäftigen und es ist sehr wichtig, Unit-Tests durchzuführen. Testen bezieht sich also auf das Testen einzelner Unterprogramme. Man hat also eine Funktion und möchte sie testen. |
| |
mehrmals, bevor Sie es in Ihr Gesamtsystem einfügen, damit Sie diese Unit-Tests durchführen können |
| |
für einzelne Module, aber das wird nicht reichen. Und ich kann Ihnen ein paar Beispiele dafür zeigen. |
| |
Beispielsweise verlor die NASA ihren Mars Climate Orbiter aus einem sehr seltsamen Grund... aufgrund eines sehr seltsamen Fehlers, weil es zwei Softwareteams gab, eines in Europa, |
| |
Einer in den USA. Und einer davon arbeitete mit der Einheit Pfund und der andere in den USA und der andere in Europa. |
| |
verwendete Newton. Sie führten also natürlich ihre Unit-Tests durch. Aber als sie ihren Code zusammenstellten, funktionierte er nicht, weil einer Newton erwartete und der andere Pfund. Sie verloren also buchstäblich die |
| |
Orbiter, nur weil sie vergessen haben, von Pfund in Newton umzurechnen. Und vor kurzem, als Starliner, verlor Boeing seinen Starliner und gab dann zu, dass sie den Fehler hätten bemerken können, wenn sie es getan hätten |
| |
einen rigorosen Integrationstest. Und am Ende zählt die |
| |
Integrationstest, da Module nicht allein im Skript existieren, sondern miteinander kommunizieren. |
| |
Und hier ist eine lustige Illustration des Problems. Sie können also zwei Objekte haben, die gründlich getestet werden. Es ist ein Fenster, richtig? Was kann bei einem Fenster schon schiefgehen? |
| |
Wenn Sie jedoch zwei davon zusammenfügen, lassen sie sich nicht einmal öffnen. Sie müssen also einige Integrationstests durchführen, um zu sehen, ob sie kombiniert werden und ob sie gut zusammenarbeiten. |
| |
Und ich möchte hier kurz erläutern, wie ich mit automatisierten Tests begonnen habe. Und zwar anhand eines konkreten Falles: |
| |
Ein schwieriger Fall, um ehrlich zu sein, denn es handelt sich um den Test eines modalen Fensters und modale Fenster verschwinden nicht, bis Sie auf eine Schaltfläche klicken. Sie müssen also |
| |
Erstellen Sie ein JMP-Skript, das auf eine Schaltfläche klickt, die ein menschliches Verhalten nachahmt, und was ich hier mache, ist, einen Tester in das |
| |
modales Fenster hier. Und das Schöne an diesem Ansatz ist, denke ich, dass Sie immer noch verteilen können |
| |
Zeigen Sie Ihren Benutzern dieses Ding, dieses Skript, und die Benutzer werden nicht einmal merken, dass darin tatsächlich eine Art Testroutine enthalten ist. |
| |
Es verfügt also über die Hooks für einen Tester, aber wenn Sie es dann alleine ausführen, sucht es nach diesem Testmodusparameter, und dieser ist nicht festgelegt. |
| |
Wenn es also nicht festgelegt ist, setzt das Skript es auf Null, wodurch alle Hooks in der Tabelle deaktiviert werden. Sie können dies also Ihren Benutzern geben und sie können es so ausführen. |
| |
Wenn Sie Ihr Skript testen möchten, erstellen Sie einen Testcode darüber. Der Testcode setzt den Testmodus auf Eins und erstellt den Tester. |
| |
Testerobjekt, das Sie in Ihr Skript einfügen möchten. In diesem speziellen Fall wählt es beispielsweise eine bestimmte Spalte aus |
| |
und dann wird ihm durch Klicken auf eine Schaltfläche eine Rolle zugewiesen und anschließend das Skript ausgeführt, richtig. Das ahmt also buchstäblich menschliches Verhalten nach. |
| |
Anschließend wird das eigentliche Skript geladen. Im Grunde werden die Parameter in das zu testende Skript eingefügt. Das Skript wird nun automatisch ausgeführt. Nach dem Klicken auf diese und jene Schaltfläche wird die Benutzeroberfläche geschlossen. |
| |
Und dann führen Sie es erneut in einer Protokollerfassungsfunktion aus, sodass Sie wissen, ob etwas schief geht, da Sie den Fehler erfassen. |
| |
Und Sie fügen es auch in den Eingabeversuch ein, damit das Skript insgesamt überlebt und das Protokoll meldet. Und wenn dann alles in Ordnung ist, erhalten Sie ein leeres Protokoll zurück, was bedeutet, dass Ihr Skript nicht fehlgeschlagen ist. |
| |
Wenn etwas schief gelaufen ist, erfahren Sie es in der Protokollerfassung. Das ist also die Idee. |
| |
Also, |
| |
Wir haben |
| |
die Möglichkeit, die Skripte zu überwachen. Wir haben die Möglichkeit, |
| |
Protokolle von Abstürzen erfassen. Also dachten wir, warum reagieren wir nicht auf das Absturzprotokoll? Wenn Sie ein Absturzprotokoll sehen, bedeutet das, dass etwas schiefgelaufen ist, und das Skript... Der Benutzer weiß das bereits, weil das Skript offensichtlich abgestürzt ist, und der Entwickler weiß, dass das Skript abgestürzt ist, weil die Protokolle |
| |
auf einem Server gespeichert. Sie stehen Ihnen also zur Verfügung. Allerdings handelt es sich noch nicht um einen geschlossenen Kreislauf, da der Benutzer nicht weiß, dass der Entwickler Bescheid weiß. Sie können diesen Kreislauf schließen, indem Sie automatisierte Tickets erstellen. Da Sie die Informationen bereits haben, können Sie |
| |
Verwenden Sie eine Bug-Tracking-Software wie JIRA Atlassian und dann können Sie die REST-Funktionalität nutzen |
| |
um die Informationen vom Server zu sammeln, ein Ticket zu erstellen, es dem Entwickler zuzuweisen und den Benutzer auch als Beobachter zu zuweisen. Der Beobachter bedeutet, dass, wann immer der Entwickler etwas tut |
| |
über den Fehler und gibt diese Informationen in JIRA ein, die dann an den Benutzer zurückgesendet werden, damit er benachrichtigt wird und weiß, dass jemand an dem Fehler arbeitet. |
| |
Und es gibt mehrere Möglichkeiten, dies zu tun, abhängig von der JIRA-Variante, die Sie haben, und ich gebe Ihnen nur die |
| |
Basiscode hier. Es ist ein Curl-Code, den Sie erstellen können. Sie sammeln die Metadaten aus den Absturzprotokollen und betten diese in eine JSL-Datei ein. Anschließend werden sie über REST übertragen und in die |
| |
JIRA, das... das wird es für Sie verfolgen. Und dann wird JIRA, wenn Sie es richtig eingerichtet haben, JIRA wird es benachrichtigen... JIRA wird den Entwickler benachrichtigen und möglicherweise |
| |
der Benutzer, bei dem das Skript abgestürzt ist. Das hängt also alles zusammen und der Entwickler weiß, dass es einen Fehler gibt, an dem er arbeiten muss, und der Benutzer weiß, dass jemand an dem Fehler arbeitet. |
| |
Okay. Damit komme ich zu meinen Schlussbemerkungen. Hier sind nur die wichtigsten Erkenntnisse, die Sie aus dieser Präsentation mitnehmen können. |
| |
Git war der Grundstein unseres Systems und hat es uns ermöglicht, viele nette Features zu entwickeln, und ich habe noch nicht einmal die grundlegenden erwähnt, die |
| |
Das liegt auf der Hand, denn dadurch können Sie auch zusammenarbeiten. Wenn also mehrere Personen am selben Skript arbeiten, können Sie alle Funktionen des |
