Altoparlante | Trascrizione |
| Serkay Olmez | Salve, sono Serkay e Fred di Seagate e oggi parleremo di come abbiamo creato un ecosistema JSL per gestire i nostri script JSL. |
| Quindi utilizziamo Git per gestire i controlli del codice sorgente, la fonte dei nostri script JSL, nonché per distribuirli. Quindi questo sarà il punto principale del discorso di oggi. |
| Ma oltre a ciò, parlerò anche dell'integrazione di VBA per PowerPoint e anche della raccolta dei registri di arresto anomalo, nonché dei test unitari. Passerò rapidamente allo schema. |
| Quindi quello di cui voglio parlare prima riguarda la nostra storia che JSL. Scrivo script in JSL da circa 10 anni circa. |
| E siamo molto contenti di dove siamo adesso, ma ci è voluto un bel po' di tempo per arrivare qui e voglio parlare delle pietre miliari della nostra esperienza, di cosa abbiamo fatto finora e perché lo abbiamo fatto. |
| E poi parleremo di Git e di come abbiamo consentito a Git di controllare il codice sorgente dei nostri script JSL e di come ci ha permesso di creare ulteriori funzionalità. Ad esempio, una volta abilitato Git, |
| puoi aggiungere più funzionalità come il monitoraggio dei tuoi script. Quindi sai che gli sviluppatori possono sapere che i loro script sono in uso, in modo che possano monitorarne l'utilizzo. |
| E, cosa probabilmente più importante, possono anche raccogliere registri. Se lo script si blocca, lo sviluppatore lo sa e può tornare indietro e correggere quei bug. E tu puoi... |
| puoi aggiungere un'altra funzionalità facendo un ulteriore passo avanti. Puoi anche creare ticket di bug automatizzati se già sai che il tuo script si è bloccato. Quindi puoi creare automaticamente un ticket di bug per questo. E puoi tenere traccia di quei biglietti utilizzando un software di monitoraggio come JIRA o Atlassian. |
| E concluderò con le nostre migliori pratiche e le lezioni apprese finora. |
| COSÌ, |
| E in appendice ho anche un manuale per una sceneggiatura di cui parlerò. È uno script che può inviare immagini a PowerPoint. |
| E ho un manuale molto dettagliato per questo, e dovrei semplicemente farti sapere che tutto ciò di cui parlo qui, i dati e gli script, saranno disponibili. |
| E sono pubblicati in un repository pubblico nella sezione dei riferimenti qui e puoi semplicemente andare lì e prendere quei file se scegli di farlo. Quindi lasciatemi iniziare |
| con la breve storia qui. Quindi 10...Lavoro con JSL da circa 10 anni o giù di lì, e ho iniziato, ho iniziato con |
| molto basilari e non sapevo molto dello scripting JSL. |
| E poi, una volta che inizi a farlo, ti rendi conto che devi avere un adeguato controllo del codice sorgente e che hai bisogno di modi adeguati per distribuire i tuoi script. |
| Quindi il vantaggio dello scripting JMP è che non ha barriere all'ingresso. Quindi puoi letteralmente creare una trama manualmente e poi andare a prendere la sceneggiatura. E' scritto per te. |
| Puoi anche utilizzare Community to JMP su JMP.com per porre domande e ottenere risposte. |
| E tu... lo scripting è così efficiente che stai facendo il tuo lavoro in modo così efficiente e la gente se ne accorgerà. Ti chiederanno come fai le cose e tu dirai che ho una sceneggiatura per quello. E lo faranno |
| chiedi: "Puoi condividerlo con me?" E all'improvviso diventi uno sviluppatore, anche se non avevi intenzione di farlo. |
| E poi devi occuparti della distribuzione dei tuoi script. La prima idea che mi viene in mente è semplicemente attaccarli, il che è un'idea orribile, e lo faccio da un bel po'. |
| Ed è abbastanza ovvio il motivo per cui non è una buona idea, perché alleghi uno script e poi lo invii e poi il giorno dopo crei un |
| revisione e poi devi inviarlo di nuovo, e non sai nemmeno se l'utente accetterà quello successivo. Quindi sto solo illustrando il punto qui. |
| Di recente ho ricevuto un'e-mail da un collega e si riferiva a uno script che ho creato nel 2017 e stavo semplicemente numerando i miei script con questi |
| numeri di versione, il che non è una buona idea. Quindi ritorna dopo tre, quattro anni e ti rendi conto che le persone usano ancora script vecchi di tre anni, perché non si aggiornavano. |
| Un modo per risolvere questo problema è utilizzare la guida condivisa e basarsi sull'interazione che ho avuto con le persone al suo interno |
| Discovery Summits, è che molte persone, molte aziende lo utilizzano. Quindi ciò che fanno gli sviluppatori è farlo |
| scarica i propri script in un'unità condivisa e gli utenti verranno estratti direttamente dall'unità condivisa, il che risolve metà del problema del problema di distribuzione, ma non fa nulla sul controllo del codice sorgente. Non... non puoi tracciare le modifiche apportate al codice. |
| Ed è per questo che ci siamo effettivamente spostati su Git. E questa è stata una svolta per noi e ha abilitato molte funzionalità. Quindi quello che fai con Git è che gli sviluppatori inviino i loro script in un repository e |
| gli utenti estrarranno i loro script direttamente da Git. Questo è stato un grande miglioramento per noi e ci ha permesso di raccogliere registri di arresti anomali e |
| utilizzo degli script, ecc. E voglio solo parlare di un altro paio di cose che ho imparato dai Summit. Sono stati molto utili per migliorare le mie capacità di scripting e ho partecipato a un summit nel 2018 e ho imparato parecchio sulle espressioni, ecc. Quindi |
| le persone potrebbero voler tornare indietro e ascoltare quelle presentazioni, perché aiutano con le capacità di scripting. |
| E un'altra pietra miliare per noi riguardava i test. Quindi sono stato ispirato da questo discorso tenuto al Summit dell'anno scorso, che riguardava i test unitari e che ti consente di testare automaticamente i tuoi script prima di pubblicarli. |
| Oggi parlerò principalmente di test di integrazione perché i test unitari sono... i test unitari sono necessari, ma non sufficienti. |
| Poiché puoi eseguire un test unitario, puoi testare tutti i tuoi moduli e funzionano correttamente. Ma quando li metti insieme, non funzioneranno. Si schianteranno, come illustrato qui. Ogni cassetto è stato testato, probabilmente, ma quando li metti insieme non funzionano. |
| Una caratteristica interessante che aiuta parecchio lo sviluppatore riguarda la raccolta dei log. |
| È molto utile sapere che il tuo script si è bloccato e, sai, come è andato in crash. E puoi farlo raccogliendo i log degli utenti e puoi tornare indietro e correggere il tuo script e inviare le modifiche, e gli utenti avranno subito il loro script corretto. |
| E l'ultima funzionalità che stiamo implementando piuttosto di recente riguarda la segnalazione automatica dei bug. Dato che hai già il rapporto sull'incidente, perché non agire in base a tali informazioni? E così creiamo un automatizzato |
| monitoraggio |
| sistema, che terrà traccia di tali registri di arresti anomali e creerà automaticamente segnalazioni di bug in modo che lo sviluppatore possa lavorarci sopra. Inoltre, puoi aggiungere l'utente come osservatore in modo che l'utente sappia che qualcuno sta lavorando al problema. Quindi è questo che risolve il problema |
| che risolve il divario informativo tra utente e sviluppatore. |
| Quindi questo mostra la sequenza temporale e dedicherò un po' di tempo a questo |
| sui singoli elementi, ma inizieremo con Git e lo costruirò rapidamente e lascerò che Fred ne parli. |
| 163084 | Va bene. |
| COSÌ, |
| Git è solo un sistema di controllo della versione e non uso la parola controllo della versione. In realtà voglio dire che Git ti aiuta dandoti, in effetti, ripetizioni illimitate, anche se usi Git solo sul tuo computer locale. Esso |
| ti dà la possibilità di tenere traccia delle revisioni dei tuoi file e tornare a quelli vecchi, nel caso in cui decidi che parte del lavoro svolto nelle ultime settimane non era corretto e desideri tornare a qualcosa di diverse settimane fa. |
| Quindi Git è solo un software che installi sul tuo computer locale. Crea un repository e quel repository può quindi essere pubblicato su altri repository. |
| Come GitLab o GitHub. TortoiseGit è un'interfaccia GUI da installare sul tuo computer locale che semplifica le cose. Quindi, Serkay, se potessi aprire la prossima diapositiva. |
| Quindi il modello che ho cercato di convincere gli sviluppatori a utilizzare è sul loro computer locale. Gli sviluppatori in locale chiedono loro di installare il client Git e di avviarlo |
| versione che controlla i file sul proprio PC locale. Una volta che avranno preso l'abitudine di farlo, potremo collegarli a un repository remoto |
| e Git si connette a repository remoti o SSH in generale o altri metodi e possono eseguire il push |
| copie del loro database Git fino al repository remoto. Una volta installato nel repository remoto, è disponibile per la condivisione da parte di un server Web HTTP e JMP |
| può quindi puntare agli URL e al server Web HTTP...HTTP e caricare gli script da esso. Quindi, invece di utilizzare un'unità condivisa, utilizziamo un server Web HTTP popolato da un push a un repository Git. |
| E poi i punti elenco in basso sottolineano semplicemente i vantaggi di ciò e come funziona esattamente. |
| Possiamo passare alla diapositiva successiva. |
| Serkay Olmez | Quindi prenderò il comando qui, Fred, e ti mostrerò... mostrerò un'implementazione di illustrazione molto semplice e gli script sono disponibili nei Riferimenti. |
| COSÌ, |
| questo sarà un codice molto semplice. E quello che mostro qui è il codice che lo sviluppatore sta sviluppando. È il minimo indispensabile, giusto. È solo una finestra di dialogo che dice: ciao mondo. |
| E supponiamo che lo sviluppatore voglia trasmettere questo codice agli utenti. Quindi, invece di fornire questo codice, ciò che lo sviluppatore passa è questo codice, |
| che è un collegamento al repository. Quindi questo è il repository dello script hello JSL che risiede lì... |
| nell'archivio remoto. Ciò che fa l'utente è semplicemente afferrare...l'utente afferra il |
| script dall'URL. Quindi questo è un codice statico. Non necessita di alcuna modifica, quindi lo sviluppatore può modificare lo script quando vuole, ma l'utente non deve fare nulla. E qui ti mostrerò solo un'illustrazione e voglio solo andare a schermo intero. |
| Basta, illustra solo come funziona questa cosa con una particolare GUI, che è ottenere GitHub Desktop. Quindi quello che fai è installare questo |
| software nel tuo computer e crea un repository locale e terranno traccia delle modifiche apportate. Ad esempio, in questo caso, ho appena creato questo script Hello JSL |
| e questo software saprà che c'è un cambiamento e lo evidenzierà automaticamente. E quello che fai è prima impegnarlo nel tuo repository locale, |
| che inserisce queste cose nel tuo repository locale e poi le spingerai fino all'origine, che è un repository remoto. Ora lo invierò al telecomando che lo renderà disponibile agli utenti. |
| Quindi, una volta fatto ciò, ora gli utenti saranno in grado di estrarre questo nuovo codice. E ora sto tornando al ruolo utente qui e questo è lo script, l'utente viene eseguito e quando... una volta fatto ciò, verrà visualizzata la finestra di dialogo. Quindi stai eseguendo lo script che hai estratto dal repository. |
| Quindi lo illustrerò... lo illustrerò un po' meglio con un codice più avanzato, che sarà anche correlato a PowerPoint. |
| Quindi le persone eseguono molte analisi in JMP e molte persone, alla fine, desiderano ancora inserire i propri risultati in PowerPoint. So che JMP ha alcune funzionalità da spingere |
| immagini direttamente in PowerPoint, ma volevamo qualcosa di più... qualcosa di un po' più sofisticato. Noi vogliamo |
| gestire il modello di PowerPoint. Vogliamo fare altre cose all'interno di PowerPoint, decidere quante immagini vogliamo inserire in una diapositiva, ecc. |
| per fare ciò, devi prima connettere JMP con PowerPoint e puoi farlo in realtà molto... |
| in un ottimo modo, così non dovrai nemmeno lasciare JMP. Quindi quello che puoi fare è individuare dove si trova il file eseguibile di PowerPoint e in genere si trova in Programmi. |
| E poi crei un file batch che attiverà questo eseguibile di PowerPoint e andrà a prendere il file di PowerPoint che desideri eseguire e lo eseguirà semplicemente. Quindi puoi fare tutto questo in JMP. Fondamentalmente ciò che fa è cercare il file eseguibile di PowerPoint. |
| E una volta individuato, lo raggruppa in questo file batch. E include anche il percorso del PowerPoint che desideri eseguire |
| e la macro e quindi PowerPoint conterrà una macro per eseguire la gestione all'interno di PowerPoint. Quindi è così che tu |
| collega JMP a PowerPoint e dovrai anche lasciare che JMP lo faccia. Ma la domanda è: come puoi iniziare a fornire questo file PowerPoint ai tuoi utenti? Potresti |
| chiedigli di andare a scaricarlo, il che non è l'ideale perché vuoi gestirlo automaticamente e allo stesso tempo vuoi controllare anche il codice sorgente del tuo PowerPoint. Quindi deve essere un buon candidato; deve essere una buona parte dell’intero ecosistema. Non vuoi metterlo fuori. |
| E un altro requisito è che non vuoi scaricare PowerPoint ogni volta che viene eseguito lo script. Quindi vuoi scaricare PowerPoint solo se è cambiato in quel repository di immagini o qualcosa di nuovo con PowerPoint. |
| Quindi, un modo per farlo è usare questo piccolo script JMP, un comando JMP che è la data di creazione. Quindi quello che sto facendo qui è controllare |
| la data del file locale. Quindi, se il PowerPoint locale è più vecchio di quello che ho nel repository, andrò a scaricarlo. COSÌ |
| andrà a scaricare PowerPoint utilizzando la richiesta HTTP e così via |
| assomiglia a questo. Quindi quello che fai è semplicemente controllare il tuo PowerPoint sul tuo computer locale. Se non esiste, puoi semplicemente estrarlo dal repository utilizzando la richiesta HTTP. Se esiste, ti piace guardare la sua data, e se è vecchio, vai ancora e |
| tira quello nuovo. Quindi la conclusione è che puoi integrare perfettamente PowerPoint nell'ambiente JMP, in modo da poter inserire i tuoi risultati in JMP, incluse tabelle e immagini. E puoi fare tutto questo senza interrompere il controllo del codice sorgente e ne mostrerò una dimostrazione qui. |
| Quindi questo sarà il codice, ad esempio, che daresti ai tuoi utenti. Ancora una volta, questo è un codice statico. In realtà non ha nulla tranne un URL che collega lo script al repository remoto. Quindi andrà a prendere il |
| Lo script JMP dal repository e tali script sono di nuovo disponibili e puoi semplicemente estrarli dai Riferimenti. |
| Dal, dal, dal lato dello sviluppatore, questo è lo script vero e proprio, giusto. Questo è lo script, lo sviluppatore ha sviluppato e |
| lui o lei lo inserisce nel repository remoto. E la cosa bella di questo script è che voglio solo sottolineare rapidamente un paio di funzionalità. |
| Quindi se, per esempio, guarda questo. Questo è uno script di testo autonomo e non è necessario distribuire file PowerPoint o script aggiuntivi |
| separatamente. Quello che fai è collegarli nel tuo script e sono collegati nel repository qui, |
| compreso il PowerPoint. Quindi questo script gestirà tutta la distribuzione. Quindi, andrà a prendere PowerPoint. |
| Andrà a prendere altri file aggiuntivi, se necessario. Quindi tutto è raggruppato nello script, quindi fa tutta la gestione per te. Quindi lasciatemelo mostrare velocemente. Lo ritirerò |
| e mettilo a schermo intero |
| così puoi vedere chiaramente. Quindi questa sarà una dimostrazione dell'attivazione automatica di PowerPoint |
| per un caso particolare. E ciò che fa questo script è ottenere i percorsi dalla tabella, questa è una tabella JMP che include molti percorsi di immagini, e quelli si riferiscono a questo particolare |
| server, prenderà quei percorsi e prenderà solo quelli evidenziati qui e li inserirà in PowerPoint. |
| Eseguirò semplicemente questo e questo script sarà a tua disposizione se vuoi provarlo. Ed è uno script utile completamente funzionale. Quindi, e lo sto eseguendo |
| sceneggiatura qui. Ancora una volta, si riferisce al repository. Quindi non ha lo script di riga, lo sta semplicemente estraendo dal repository. Lo esegui, recupera il codice, esegue un dialogo. |
| E lo eseguirò semplicemente. Non entrerò nei dettagli e, una volta eseguito, attiverà automaticamente PowerPoint. |
| E PowerPoint verrà avviato e poi... sta iniziando... sta costruendo le diapositive qui. Verranno estratti 20 immagini e ci vorranno 10 o 20 secondi e poi avrai PowerPoint |
| Fatto. Quindi questo è il PowerPoint che ottieni e tutto viene eseguito automaticamente e tutto è stato estratto dal repository. |
| Quindi qual è il prossimo passo? Come rivedresti questo PowerPoint? Quindi presumo che tu voglia apportare alcune modifiche al tuo modello. E |
| puoi vedere maggiori dettagli a riguardo nell'appendice, ma quello che voglio mostrare è come modificare il file |
| script in PowerPoint. E andrò a schermo intero, |
| e lo eseguirò semplicemente. Ciò da cui stiamo iniziando è ciò che ci rimane nella diapositiva precedente, a destra, quindi avete queste immagini. |
| Quello che voglio fare è modificare il modello in modo banale, semplicemente per illustrare il punto. Quindi vai a... |
| vai alla macro, scorri verso il basso e trovi la cosa che vuoi cambiare, e qui farò una semplice modifica. Cambierò il colore dell'intestazione solo per sottolineare un punto, giusto. Quindi cambia questo |
| E |
| salvarla. E questo avverrà in tempo reale. |
| Lo salvi e puoi eliminare le diapositive in modo che vadano più velocemente nel repository, perché lo inserirai nel repository. |
| E poi lo escludi utilizzando la GUI di Git. Andrà nel repository |
| e lo renderà disponibile ai tuoi utenti. Quindi tutti i tuoi utenti riceveranno immediatamente la modifica. Quindi non devi chiedere loro di andare ad aggiornare PowerPoint o altro. |
| Questo andrà semplicemente nel repository. |
| E tornerò a JMP e in modalità utente, quindi eseguirò nuovamente lo script, che recupererà il nuovo PowerPoint. |
| E se lo esegui di nuovo, passerà attraverso il |
| diapositive, creerà la diapositiva. E quello che noterai è che hai le modifiche, che riguardavano il cambiamento del colore della riga di intestazione. |
| COSÌ, |
| cos'altro abbiamo? |
| Monitoraggio della sceneggiatura. Penso che questa sia stata una delle migliori funzionalità che abbiamo sviluppato, perché dà la possibilità allo sviluppatore di vedere se |
| la loro sceneggiatura...la sua, la sua sceneggiatura è apprezzata o no. Giusto. Allora è corsa? Qualcuno lo esegue regolarmente? |
| Quindi questo è un vantaggio. L'altro vantaggio riguarda |
| log...raccolta del registro degli arresti anomali. Pertanto, se lo script non riesce, è possibile acquisire l'errore utilizzando questa funzionalità di acquisizione del registro di JMP. Quindi inserisci le tue subroutine nell'acquisizione del registro. |
| Se fallisce...il fallimento...il registro dell'errore verrà restituito in questo testo restituito dal registro. E poi anche quello che fai sei tu |
| racchiuderlo in un tentativo, in modo che lo script sopravviva ancora per effettuare la segnalazione. |
| E poi controlli se è vuoto. Se è vuoto, significa che non si è verificato alcun arresto anomalo del sistema, quindi i tuoi script sono sopravvissuti. |
| Ma in caso contrario, se non è vuoto, significa che c'è stato un incidente e tu l'hai contenuto. Puoi prendere il registro e ora puoi segnalarlo. E il modo per farlo è usare HTTP |
| ID utente, nome dello script e nota di registro, se si tratta di un arresto anomalo... |
| se si è trattato di un incidente o semplicemente di una corsa regolare, forse alcuni parametri di prestazione. Quindi la conclusione è che puoi trasmettere alcuni metadati di dati sul tuo script allo sviluppatore. |
| E ciò che farà il server è registrarli e avrai una serie di file archiviati nel server e potrai monitorarli. E sto solo mostrando un campione |
| tavolo da questi. È un registro degli arresti anomali, che ha... che ha la data, ha un nome di script, quindi questo script non è riuscito in quella data |
| con questo particolare incidente. Quindi questo è estremamente utile per lo sviluppatore perché può tornare indietro e risolvere il problema. Quindi comprimerò questo e questo e farò una rapida dimostrazione qui che mostra come stai |
| come tu |
| contenere l'arresto anomalo e il modo in cui segnalarlo all'utente. Quindi quello che farò qui è causare un crash della subroutine. Creerò un parametro non definito |
| e JMP si lamenterà. Dirà che questa cosa non è definita, quindi lo script si sta bloccando. Ma quello che farò è chiamare quella subroutine |
| in una funzionalità di acquisizione del registro e tutto verrà inserito in prova. Quindi, anche se lo script si è bloccato con la subroutine, sopravviverà nel complesso e sarà in grado di segnalare a |
| rapporto sull'incidente. Quindi dai una bella notifica ben formattata all'utente e lo dici. Quindi gli script si bloccano con questo particolare errore e abbiamo creato un registro per questo e ci stiamo lavorando. Quindi questa è la notifica che dai loro... all'utente. |
| Quindi una cosa fondamentale che ho imparato durante i summit riguardava i test automatizzati. Quindi facevo i miei test manualmente, il che è molto frustrante. |
| Perché ci vuole tempo e non puoi catturare ogni singolo angolo della tua sceneggiatura. È impossibile fare ore di test quando si apporta una piccola modifica. |
| Quindi ho iniziato ad dedicarmi ai test automatizzati ed è molto importante eseguire test unitari. Quindi, sai, il test si riferisce al test delle singole subroutine. Quindi hai una funzione e vuoi testarla |
| più volte prima di inserirlo nel sistema generale, in modo da poter eseguire questi test unitari |
| per i singoli moduli, ma non sarà sufficiente. E posso mostrarti un paio di esempi di ciò. |
| Ad esempio, la NASA ha perso il Mars Climate Orbiter per un errore molto strano... a causa di un errore molto strano perché c'erano due team software, uno in Europa, |
| uno negli Stati Uniti. E uno di loro lavorava con le unità di sterline e quello in, sì, quello era quello negli Stati Uniti e quello in Europa |
| usava i Newton. Quindi hanno sicuramente fatto i loro test unitari. Ma quando hanno messo insieme il loro codice, non ha funzionato, perché uno si aspettava Newton e l'altro riceveva sterline. Quindi hanno letteralmente perso il |
| Orbiter, solo perché si sono dimenticati di convertire le sterline in Newton. E più recentemente come Starliner, la Boeing ha perso il suo Starliner e poi ha ammesso che avrebbe potuto cogliere l'errore se lo avesse fatto |
| un rigoroso test di integrazione. E alla fine, ciò che conta è il |
| test di integrazione perché i moduli non vivono da soli nello script, parlano insieme. |
| E questa è una divertente illustrazione del problema qui. Quindi puoi avere due oggetti che vengono testati accuratamente. È una finestra, giusto, cosa può andare storto con una finestra? |
| Ma se ne metti due insieme, non si apriranno nemmeno, quindi devi fare alcuni test di integrazione per vedere se sono combinati, se funzionano bene insieme. |
| E voglio illustrare qui un breve punto che mostra come ho iniziato a eseguire test automatizzati. E questo si riferirà ad un caso particolare, cioè |
| un caso difficile, ad essere onesti, perché questo testerà una finestra modale e le finestre modali non scompariranno a meno che non si faccia clic su un pulsante. Quindi devi farlo |
| creare uno script JMP che fa clic su un pulsante, che imita un comportamento umano, e quello che sto facendo qui è inserire un tester nel |
| finestra modale qui. E la cosa bella di questo approccio, penso, è che puoi ancora distribuire |
| questa cosa, questo script per i tuoi utenti e gli utenti non si renderanno nemmeno conto che in realtà c'è una routine di test al suo interno. |
| Quindi ha gli hook per un tester, ma se lo esegui da solo, quello che fa è cercare questo parametro della modalità test e non è impostato. |
| Quindi, se non è impostato, lo script lo imposterà su zero e ciò disabiliterà tutti gli hook nella tabella. Quindi puoi darlo ai tuoi utenti e loro possono eseguirlo come questo. |
| Tuttavia, se vuoi testare il tuo script, quello che fai è creare un codice tester sopra di esso. Quindi il codice del tester imposterà la modalità test su uno e creerà anche il tester... |
| oggetto tester che desideri inserire nel tuo script. Ad esempio, in questo caso particolare, ciò che fa è selezionare una colonna particolare |
| e poi gli assegna un ruolo facendo clic su un pulsante e quindi esegue lo script, giusto. Quindi questo sta letteralmente imitando un comportamento umano. |
| Quindi caricherà lo script vero e proprio. Quindi sostanzialmente si tratta di inserire quei parametri nello script che vuoi testare. Ora stai eseguendo lo script automaticamente, quindi caricherà lo script, lo eseguirà e chiuderà l'interfaccia utente dopo aver fatto clic su questo pulsante e su quel pulsante. |
| E poi quello che fai è eseguirlo di nuovo in una funzionalità di acquisizione del registro, in modo da sapere se qualcosa va storto, catturerai l'errore. |
| E lo inserisci anche in enter try in modo che, nel complesso, lo script sopravviva per riportare il registro. E poi, se non c'era niente di sbagliato, otterrai un registro vuoto e ciò significa che il tuo script non ha fallito. |
| Se qualcosa è andato storto, lo saprai nella cattura del registro. Quindi questa è l'idea. |
| COSÌ, |
| Abbiamo |
| la capacità di monitorare gli script. Ne abbiamo la capacità |
| acquisire i registri degli arresti anomali. Quindi abbiamo pensato: perché non agire in base al registro degli arresti anomali? Se vedi un registro di arresto anomalo significa che qualcosa è andato storto e lo script che... l'utente lo sa già perché lo script si è bloccato ovviamente e lo sviluppatore sa che lo script si è bloccato perché i registri sono |
| memorizzati in un server. Quindi sono lì affinché tu possa agire. Ma il fatto è che questo non è ancora un ciclo chiuso, perché l'utente non sa che lo sviluppatore lo sa. E puoi chiudere questo ciclo creando ticket automatizzati. Quindi, poiché hai già le informazioni, puoi farlo |
| utilizza un software di tracciamento dei bug come JIRA Atlassian e quindi puoi utilizzare la funzionalità REST |
| per raccogliere le informazioni dal server, creare un ticket, assegnarlo allo sviluppatore e puoi anche assegnare l'utente come osservatore. L'osservatore significa che ogni volta che lo sviluppatore fa qualcosa |
| sul bug e inserisce tali informazioni in JIRA, che verrà restituito all'utente in modo che venga avvisato e saprà che qualcuno sta lavorando al bug. |
| E ci sono diversi modi per farlo, a seconda del sapore di JIRA che hai, e te lo sto solo dando |
| codice base qui. È un codice curl che puoi creare e raccogli i metadati che hai dai registri degli arresti anomali e li incorpori in un file JSL e poi verrà trasmesso tramite REST e andrà nel |
| JIRA, che è...che lo seguirà per te. E poi JIRA, se impostato correttamente, JIRA lo avviserà... JIRA avviserà lo sviluppatore e possibilmente |
| l'utente per il quale...per il quale lo script si è bloccato. E quindi tutto questo è legato insieme e lo sviluppatore saprà che c'è un bug su cui deve lavorare e l'utente saprà che qualcuno lavorerà sul bug. |
| Va bene. Penso che questo mi porti alle mie note conclusive. Solo i suggerimenti che puoi trarre da questa presentazione. |
| Git è stato la pietra angolare del nostro sistema e ci ha permesso di realizzare molte funzionalità interessanti e non ho nemmeno menzionato quelle di base, che |
| che sono abbastanza ovvi, perché questo ti dà anche la capacità di collaborare. Quindi, se siete più persone che lavorano sullo stesso script. Puoi utilizzare tutte le funzionalità di |
