Vocero | Transcripción |
| Serkay Olmez | Hola, soy Serkay y Fred de Seagate y hoy vamos a hablar sobre cómo construimos un ecosistema JSL para administrar nuestros scripts JSL. |
| Por eso utilizamos Git para gestionar los controles de código fuente, el código fuente de nuestros scripts JSL, así como para distribuirlos. Ese será el punto principal de la charla de hoy. |
| Pero además de eso, también hablaré sobre VBA para la integración de PowerPoint y también sobre la recopilación de registros de fallos, así como sobre las pruebas unitarias. Saltaré al esquema rápidamente. |
| Entonces, de lo que quiero hablar primero es de nuestra historia, JSL. He estado escribiendo scripts en JSL durante aproximadamente 10 años. |
| Y estamos muy contentos con el lugar donde nos encontramos ahora, pero nos tomó bastante tiempo llegar aquí y quiero hablar sobre los hitos de nuestra experiencia, lo que hicimos hasta ahora y por qué lo hicimos. |
| Y luego hablaremos sobre Git y cómo permitimos que Git controlara el código fuente de nuestros scripts JSL y cómo nos permitió crear más funciones. Por ejemplo, una vez que habilitas Git, |
| puede agregar más funciones, como monitorear sus scripts. Entonces sabes que los desarrolladores pueden saber que sus scripts están en uso, por lo que pueden monitorear el uso. |
| Y probablemente lo más importante es que también pueden recopilar registros. Si el script falla, el desarrollador lo sabe y puede regresar y corregir esos errores. Y tu puedes... |
| puedes agregar una característica más para ir un paso más allá. Incluso puede crear tickets de error automatizados si ya sabe que su script falló. Entonces puedes crear automáticamente un ticket de error para eso. Y puedes realizar un seguimiento de esos tickets utilizando un software de seguimiento como JIRA o Atlassian. |
| Y terminaré con nuestras mejores prácticas y lecciones aprendidas hasta ahora. |
| Entonces, |
| Y en el apéndice también tengo un manual para un guión del que hablaré. Es un script que puede enviar imágenes a PowerPoint. |
| Y tengo un manual muy detallado para eso, y debería hacerles saber que todo lo que hablo aquí, los datos y los guiones, estarán disponibles. |
| Y están publicados en un repositorio público en la sección de referencias aquí y usted puede simplemente ir allí y obtener esos archivos si así lo desea. Así que déjame empezar con |
| con la breve historia aquí. Entonces 10... He estado trabajando con JSL durante aproximadamente 10 años y comencé, comencé con |
| muy básico y realmente no sabía mucho sobre secuencias de comandos JSL. |
| Y luego, una vez que comienzas a hacer eso, te das cuenta de que debes tener un control de fuente adecuado y necesitas formas adecuadas de distribuir tus scripts. |
| Entonces, lo que pasa con las secuencias de comandos JMP es que no tienen barreras de entrada. Entonces, literalmente, puedes hacer una trama manualmente y luego tomar el guión. Está escrito para ti. |
| Y también puede utilizar Community to JMP en JMP.com para hacer preguntas y obtener respuestas. |
| Y tú... el scripting es tan eficiente que estás haciendo tu trabajo de manera tan eficiente y la gente lo notará. Te preguntarán cómo haces las cosas y dirás que tengo un guión para eso. Y lo harán |
| Pregunte: "¿Puedes compartir eso conmigo?" Y de repente te conviertes en desarrollador, aunque no tenías intención de hacerlo. |
| Y luego tienes que ocuparte de distribuir tus guiones. La primera idea que me viene a la mente es simplemente adjuntarlos, lo cual es una idea horrible y lo he hecho durante bastante tiempo. |
| Y es bastante obvio por qué no es una buena idea, porque adjuntas un guión y luego lo envías y al día siguiente haces un |
| revisión y luego tienes que enviarla de nuevo, y ni siquiera sabes si el usuario seguirá con la siguiente. Así que aquí sólo estoy ilustrando el punto. |
| Recientemente, recibí un correo electrónico de un colega y se refería a un guión que creé en 2017 y simplemente estaba numerando mis guiones con estos |
| números de versión, lo cual no es una buena idea. Entonces regresa después de tres, cuatro años y te das cuenta de que la gente todavía usa scripts de hace tres años porque no los actualizaron. |
| Una forma de resolver este problema es utilizar un disco compartido y, según la interacción que tuve con las personas en ellos en el |
| Discovery Summits, es que mucha gente, muchas empresas están utilizando este. Entonces, ¿qué hacen los desarrolladores es |
| descargue sus scripts en una unidad compartida y los usuarios los extraerán directamente de la unidad compartida, lo que resuelve la mitad del problema de distribución, pero no hace nada con respecto al control de fuente. No... no puedes rastrear los cambios que hiciste en el código. |
| Y es por eso que nos mudamos a Git. Y eso fue un gran avance para nosotros y permitió muchas funciones. Entonces, lo que se hace con Git es que los desarrolladores enviarán sus scripts a un repositorio y |
| los usuarios extraerán sus scripts directamente de Git. Eso fue una gran mejora para nosotros y nos permitió recopilar registros de fallas y |
| uso de los guiones, etc. Y solo quiero hablar sobre un par de cosas más que aprendí de las Cumbres también. Han sido muy útiles para mejorar mis habilidades de programación y asistí a una cumbre en 2018 y aprendí bastante sobre expresiones, etc. |
| Es posible que la gente quiera volver y escuchar esas presentaciones, porque ayudan con las habilidades de redacción de guiones. |
| Y otro hito para nosotros fue el de las pruebas. Me inspiré en esta charla en la Cumbre del año pasado, que trataba sobre pruebas unitarias y que le permiten probar automáticamente sus scripts antes de publicarlos. |
| Hoy hablaré principalmente sobre pruebas de integración porque las pruebas unitarias son... las pruebas unitarias son necesarias, pero no suficientes. |
| Como puedes hacer una prueba unitaria, puedes probar todos tus módulos y funcionan bien. Pero cuando los juntas, no funcionarán. Se estrellarán, como se ilustra aquí. Probablemente se prueba cada cajón, pero cuando los juntas, no funcionan. |
| Una característica interesante que ayuda bastante al desarrollador es la recopilación de registros. |
| Es muy útil saber que su script falló y, ya sabe, cómo falló. Y puede hacerlo recopilando los registros de los usuarios y puede regresar y corregir su script e impulsar los cambios, y los usuarios tendrán su script arreglado de inmediato. |
| Y la última característica que estamos implementando recientemente es la notificación automática de errores. Dado que ya tiene el informe de fallo, ¿por qué no actuar en función de esa información? Y entonces creamos un sistema automatizado. |
| supervisión |
| sistema, que rastreará esos registros de fallas y creará informes de errores automáticamente para que el desarrollador pueda trabajar en ellos. Y además, puede agregar al usuario como observador para que sepa que alguien está trabajando en el problema. Entonces eso es lo que resuelve el |
| que resuelve la brecha de información entre el usuario y el desarrollador. |
| Esto muestra la línea de tiempo y dedicaré algo de tiempo a ello. |
| en los elementos individuales, pero comenzaremos con Git y lo construiré rápidamente y dejaré que Fred hable con esto. |
| 163084 | Bueno. |
| Entonces, |
| Git es solo un sistema de control de versiones y no uso la palabra control de versiones. En realidad, quiero decir que Git te ayuda brindándote, efectivamente, rehacer ilimitado, incluso si usas Git solo en tu propia computadora local. Él |
| le brinda la posibilidad de realizar un seguimiento de las revisiones de sus archivos y volver a los antiguos, en caso de que decida que algún trabajo que realizó en las últimas semanas fue incorrecto y desea volver a algo de hace varias semanas. |
| Entonces Git es solo un software que instalas en tu computadora local. Crea un repositorio y ese repositorio luego se puede publicar en otros repositorios. |
| Como GitLab o GitHub. TortoiseGit es una interfaz GUI para acceder a su máquina local que facilita las cosas. Entonces, Serkay, si pudieras abrir la siguiente diapositiva. |
| Entonces, el modelo que he intentado que los desarrolladores utilicen está en su computadora local. Los desarrolladores locales les piden que instalen el cliente Git y comiencen |
| versión que controla los archivos en su PC local. Una vez que se acostumbren a hacerlo, podremos conectarlos a un repositorio remoto. |
| y Git se conecta a repositorios remotos o SSH en general u otros métodos y pueden enviar |
| copias de su base de datos Git hasta el repositorio remoto. Una vez que esté en el repositorio remoto, estará disponible para que un servidor web HTTP lo comparta y JMP. |
| Luego puede apuntar a las URL y al servidor web HTTP...HTTP y cargar scripts desde él. Entonces, en lugar de usar una unidad compartida, usamos un servidor web HTTP que se llenó mediante un envío a un repositorio Git. |
| Y luego, las viñetas a continuación simplemente señalan los beneficios de esto y cómo funciona exactamente. |
| Podemos pasar a la siguiente diapositiva. |
| Serkay Olmez | Así que me haré cargo aquí, Fred, y te mostraré... mostraré una implementación de ilustración muy básica, y los guiones están disponibles en las Referencias. |
| Entonces, |
| Este será un código muy básico. Y lo que estoy mostrando aquí es el código que está desarrollando el desarrollador. Es lo mínimo indispensable, ¿verdad? Es solo un cuadro de diálogo que dice hola mundo. |
| Y supongamos que el desarrollador quiere pasar este código a los usuarios. Entonces, en lugar de dar este código, lo que el desarrollador pasa es este código, |
| que es un enlace al repositorio. Así que este es el repositorio del script hello JSL que se encuentra allí... |
| en el repositorio remoto. Lo que hace el usuario es simplemente agarrar... el usuario toma el |
| script de la URL. Entonces este es un código estático. No necesita ningún cambio, por lo que el desarrollador puede cambiar el script cuando quiera, pero el usuario no tiene que hacer nada. Y solo les mostraré una ilustración aquí y solo quiero ir a la pantalla completa. |
| Simplemente, solo ilustra cómo funciona esto con una GUI en particular, que es obtener GitHub Desktop. Entonces lo que haces es instalar esto. |
| software en su computadora y cree un repositorio local, y ellos realizarán un seguimiento de los cambios que haya realizado. Por ejemplo, en este caso, acabo de crear este script JSL de hola. |
| y este software sabrá que hay un cambio y lo resaltará automáticamente. Y lo que debes hacer es, primero enviarlo a tu repositorio local, |
| que envía esas cosas a su repositorio local y luego las enviará al origen, que es un repositorio remoto. Ahora lo enviaré al control remoto que lo pondrá a disposición de los usuarios. |
| Entonces, una vez que haga eso, los usuarios podrán extraer este nuevo código. Y ahora estoy volviendo al rol de usuario aquí y este es el script, el usuario se ejecuta, y cuando... una vez que hagas eso, aparecerá el cuadro de diálogo. Entonces estás ejecutando el script que extrajiste del repositorio. |
| Así que ilustraré... ilustraré esto un poco mejor con un código más avanzado, que también estará relacionado con PowerPoint. |
| Entonces la gente hace muchos análisis en JMP y mucha gente todavía, al final del día, quiere enviar sus resultados a PowerPoint. Sé que JMP tiene algunas capacidades para impulsar |
| imágenes directamente a PowerPoint, pero queríamos un poco más... algo un poco más sofisticado. Queremos |
| gestionar la plantilla del PowerPoint. Queremos hacer algunas cosas más dentro del PowerPoint, decidir cuántas, cuántas imágenes queremos poner por diapositiva, etc. Y |
| Para hacer eso, primero necesitas conectar JMP con PowerPoint y puedes hacerlo realmente muy... |
| de muy buena manera para que ni siquiera tengas que salir de JMP. Entonces, lo que puede hacer es ubicar dónde está su archivo ejecutable de PowerPoint, y generalmente está en Archivos de programa. |
| Y luego crea un archivo por lotes que activará este ejecutable de PowerPoint, tomará el archivo de PowerPoint que desea ejecutar y simplemente lo ejecutará. Entonces puedes hacer todo esto en JMP. Básicamente, lo que hace es buscar el archivo ejecutable de PowerPoint. |
| Y una vez que lo localiza, lo agrupa en este archivo por lotes. Y también incluye la ruta al PowerPoint que deseas ejecutar. |
| y la macro, por lo que PowerPoint tendrá una macro para realizar la administración dentro de PowerPoint. Entonces así es como tú |
| vincule JMP a PowerPoint e incluso tendrá que dejar el JMP para hacer eso. Pero la pregunta es, para empezar, ¿cómo se puede hacer llegar este archivo de PowerPoint a los usuarios? Tú podrías |
| Pídale que vaya y lo descargue, lo cual no es ideal porque desea administrar esto automáticamente y al mismo tiempo desea controlar el origen de su PowerPoint también. Por eso tiene que ser un buen candidato; debe ser una buena parte de todo el ecosistema. No querrás dejarlo afuera. |
| Y otro requisito es que no deseas descargar PowerPoint cada vez que se ejecuta el script. Por lo tanto, desea descargar PowerPoint solo si ha cambiado en ese repositorio de imágenes o si hay algo nuevo con PowerPoint. |
| Entonces, una forma de hacerlo es usar este pequeño script JMP, un comando JMP que es la fecha de creación. Así que lo que estoy haciendo aquí es comprobar |
| la fecha del archivo local. Entonces, si el PowerPoint local es más antiguo que el que tengo en el repositorio, lo descargaré. Entonces |
| irá y descargará el PowerPoint mediante una solicitud HTTP y |
| se parece a esto. Entonces, lo que debe hacer es simplemente revisar su PowerPoint en su computadora local. Si no existe, puede simplemente extraerlo del repositorio mediante una solicitud HTTP. Si existe, te gusta mirar su fecha, y si es antiguo, igualmente vas y |
| tira el nuevo. Entonces, la conclusión aquí es que puede integrar PowerPoint sin problemas en el entorno JMP, para que pueda enviar sus resultados a JMP, incluidas tablas e imágenes. Y puedes hacer todo esto sin romper el control de fuente y mostraré una demostración aquí. |
| Este será el código que, por ejemplo, le darías a tus usuarios. Nuevamente, este es código estático. Realmente no tiene nada excepto una URL, que vincula el script al repositorio remoto. Entonces irá y agarrará el |
| Secuencia de comandos JMP del repositorio y esas secuencias de comandos están nuevamente disponibles y puede extraerlas de las Referencias. |
| Desde el lado del desarrollador, este es el script real, ¿verdad? Este es el script que el desarrollador ha desarrollado y |
| él o ella lo envía a un repositorio remoto. Y lo bueno de este script es que solo quiero señalar aquí un par de características rápidamente. |
| Entonces, si, por ejemplo, mira esto. Este es un script de texto independiente y no es necesario distribuir archivos de PowerPoint ni scripts adicionales. |
| por separado. Lo que haces es vincularlos en tu script y están vinculados en el repositorio aquí, |
| incluido el PowerPoint. Entonces este script gestionará toda la distribución. Entonces, irá y tomará el PowerPoint. |
| Irá y tomará otros archivos adicionales si es necesario. Entonces, todo está incluido en el script, por lo que hace toda la gestión por usted. Así que déjame mostrarte esto rápidamente. voy a retirar esto |
| y ponerlo en pantalla completa |
| para que puedas ver claramente. Esta será una demostración de cómo activar PowerPoint automáticamente. |
| para ello para un caso particular. Y lo que hace este script es obtener las rutas de la tabla, esta es una tabla JMP que incluye muchas rutas de imágenes, y esas se refieren a esta tabla en particular. |
| servidor, y tomará esas rutas y solo tomará las resaltadas aquí y las insertará en PowerPoint. |
| Simplemente ejecutaré esto y este script estará disponible para usted si desea probarlo. Y es un script útil y completamente funcional. Entonces, estoy ejecutando esto |
| guión aquí. Nuevamente, se refiere al repositorio. Entonces no tiene el script de fila, simplemente lo extrae del repositorio. Lo ejecutas, recupera el código, ejecuta un diálogo. |
| Y simplemente ejecutaré esto. No entraré en detalles y, una vez que lo ejecutes, activará PowerPoint automáticamente. |
| Y PowerPoint se iniciará y luego... está comenzando... está construyendo las diapositivas aquí. Extraerá 20 imágenes y esto tomará 10 o 20 segundos y luego tendrás el PowerPoint. |
| hecho. Este es el PowerPoint que obtienes y todo se hace automáticamente y todo se extrae del repositorio. |
| Entonces, ¿qué sigue? ¿Cómo revisarías este PowerPoint? Entonces, supongo que deseas realizar algunos cambios en tu plantilla. Y |
| Puedes ver más detalles sobre esto en el apéndice, pero lo que quiero mostrar es cómo se cambia el |
| guión en el PowerPoint. Y pasaré a la pantalla completa, |
| y simplemente ejecutaré esto. De lo que partimos es de lo que nos quedó en la diapositiva anterior, claro, entonces tenías estas imágenes. |
| Lo que quiero hacer es cambiar la plantilla de una manera trivial, solo ilustra el punto. Entonces vas a... |
| vas a la macro, te desplazas hacia abajo y encuentras lo que deseas cambiar, y haré un cambio simple aquí. Cambiaré el color del encabezado solo para dejar claro un punto, ¿verdad? Entonces cambias esto |
| y |
| guárdalo. Y esto va en tiempo real. |
| Guarda esto y puede eliminar las diapositivas para que vaya más rápido al repositorio, porque lo enviará al repositorio. |
| Y luego sacas esto usando Git GUI. Irá al repositorio. |
| y lo pondrá a disposición de sus usuarios. Entonces todos sus usuarios recibirán la modificación al instante. Entonces, no es necesario que les pidas que actualicen el PowerPoint ni nada. |
| Esto simplemente va al repositorio. |
| Y volveré a JMP y al modo de usuario y luego ejecutaré el script nuevamente, lo que recuperará el nuevo PowerPoint. |
| Y si lo ejecutas de nuevo, pasará por el |
| diapositivas, creará la diapositiva. Y lo que notarás es que tienes los cambios, que se referían a cambiar el color de la línea del encabezado. |
| Entonces, |
| ¿Qué más tenemos? |
| Seguimiento de guiones. Creo que esta fue una de las mejores características que desarrollamos, porque le da al desarrollador la posibilidad de ver si |
| su guión... el suyo, su guión es apreciado o no. Bien. Entonces, ¿se ejecuta? ¿Alguien lo ejecuta regularmente? |
| Entonces ese es un beneficio. El otro beneficio es aproximadamente |
| log... recopilación de registros de fallos. Entonces, si el script falla, puede capturar el error utilizando esta funcionalidad de captura de registros de JMP. Entonces intercalas tus subrutinas en la captura de registros. |
| Si falla... el error... el registro del error se devolverá en este texto devuelto por el registro. Y luego lo que tu también haces eres tu |
| Inclúyalo en un intento, para que el script aún sobreviva para realizar el informe. |
| Y luego compruebas si está vacío. Si está vacío, significa que no hubo ningún bloqueo, por lo que sus scripts sobrevivieron. |
| Pero si no, si no está vacío, significa que hubo un accidente y lo contuviste. Puedes tomar el registro y ahora puedes reportarlo. Y la forma de hacerlo es usar HTTP. |
| ID de usuario, el nombre del script y la nota de registro, si se trata de un bloqueo... |
| Ya sea que se haya producido un fallo o simplemente una ejecución normal, tal vez algunas métricas de rendimiento. Entonces, la conclusión es que puede transmitir algunos metadatos de datos sobre su script al desarrollador. |
| Y lo que hará el servidor es registrarlos y tendrá un conjunto de archivos almacenados en el servidor y podrá monitorearlos. Y solo estoy mostrando una muestra. |
| mesa de estos. Es un registro de fallas, que tiene... que tiene la marca de fecha, tiene un nombre de secuencia de comandos, por lo que esta secuencia de comandos falló en la fecha. |
| con este accidente en particular. Esto es extremadamente útil para el desarrollador porque puede regresar y solucionar el problema. Así que colapsaré esto y esto y haré una demostración rápida aquí que muestra cómo |
| Como tu |
| contiene el fallo y cómo informarlo al usuario. Entonces, lo que haré aquí es provocar que una subrutina se bloquee. Crearé un parámetro indefinido |
| y JMP se quejará. Dirá que esto no está definido, por lo que el script falla. Pero lo que haré es llamar a esa subrutina. |
| en una funcionalidad de captura de registros y todo se incluirá en el intento. Entonces, aunque el script falló con la subrutina, sobrevivirá en general y podrá informar un |
| informe del accidente. Entonces, ¿le da una notificación agradable y bien formateada al usuario y le dice eso? Entonces los scripts fallan con este error en particular, creamos un registro y estamos trabajando en ello. Entonces esa es la notificación que les das... al usuario. |
| Una cosa clave que aprendí en las Cumbres fue sobre las pruebas automatizadas. Entonces solía hacer mis pruebas manualmente, lo cual es muy frustrante. |
| Porque lleva tiempo y no puedes capturar todos y cada uno de los rincones de tu guión. Es imposible hacer horas de pruebas cuando haces un pequeño cambio. |
| Entonces comencé a involucrarme en las pruebas automatizadas y es muy importante realizar pruebas unitarias. Entonces, ya sabes, las pruebas se refieren a las pruebas de subrutinas individuales. Entonces tienes una función y quieres probarla. |
| varias veces antes de colocarlo en su sistema general, para que pueda realizar estas pruebas unitarias |
| para módulos individuales, pero no será suficiente. Y puedo mostrarles un par de ejemplos de eso. |
| Por ejemplo, la NASA perdió su Mars Climate Orbiter por un error muy extraño... debido a un error muy extraño porque había dos equipos de software, uno en Europa, |
| uno en EE.UU. Y uno de ellos estaba trabajando con las unidades de libras y la de, sí, esa era la de EE. UU. y la de Europa. |
| Estaba usando Newtons. Entonces ciertamente hicieron sus pruebas unitarias. Pero cuando armaron su código, no funcionó, porque uno esperaba Newtons y el otro estaba ganando libras. Así que literalmente perdieron el |
| Orbiter, sólo porque se olvidaron de convertir libras a Newtons. Y más recientemente, como Starliner, Boeing perdió su Starliner y luego admitieron que podrían haber detectado el error si lo hubieran hecho. |
| una rigurosa prueba de integración. Y al final del día, lo que cuenta es el |
| prueba de integración porque los módulos no viven solos en el script, sino que hablan entre sí. |
| Y esta es una ilustración divertida del problema aquí. De modo que puede tener dos objetos que se prueban exhaustivamente. Es una ventana, ¿verdad? ¿Qué puede salir mal con una ventana? |
| Pero si tienes dos juntos, ni siquiera se abren, así que tienes que hacer algunas pruebas de integración para ver si están combinados, si funcionan bien juntos. |
| Y quiero ilustrar un punto breve aquí que muestra cómo comencé a realizar pruebas automatizadas. Y esto se referirá a un caso particular, que es |
| Un caso difícil, para ser justos, porque será una prueba de una ventana modal y las ventanas modales no desaparecerán a menos que hagas clic en un botón. Entonces tienes que |
| cree un script JMP que haga clic en un botón, que en cierto modo imita un comportamiento humano, y lo que estoy haciendo aquí es inyectar un probador en el |
| ventana modal aquí. Y creo que lo bueno de este enfoque es que aún puedes distribuir |
| esta cosa, este script para sus usuarios y los usuarios ni siquiera se darán cuenta de que en realidad contiene alguna rutina de prueba. |
| Tiene los ganchos para un probador, pero luego ejecuta esto solo, lo que hace es buscar este parámetro del modo de prueba y no está configurado. |
| Entonces, si no está configurado, el script lo establecerá en cero, lo que deshabilitará todos los enlaces en la tabla. Entonces puedes darle esto a tus usuarios y ellos pueden ejecutarlo así. |
| Sin embargo, si desea probar su script, lo que debe hacer es crear un código de prueba sobre él. Entonces el código del probador establecerá el modo de prueba en uno y también creará el probador... |
| objeto tester que desea inyectar en su script. Por ejemplo, en este caso particular, lo que hace es seleccionar una columna en particular. |
| y luego le asigna una función haciendo clic en un botón y luego ejecuta el script, ¿verdad? Eso es literalmente imitar un comportamiento humano. |
| Entonces cargará el script real. Básicamente se trata de inyectar esos parámetros en el script que desea probar. Ahora está ejecutando el script automáticamente, por lo que lo cargará y lo ejecutará, y cerrará la interfaz de usuario después de hacer clic en este botón y en ese botón. |
| Y luego lo que hace es ejecutarlo nuevamente en una función de captura de registros, para saber si algo sale mal, capturará el error. |
| Y también lo coloca en el intento de entrada para que, en general, el script sobreviva para informar el registro. Y luego, si no pasó nada, obtendrá un retorno de registro vacío y eso significa que su secuencia de comandos no falló. |
| Si algo salió mal, lo sabrás en la captura del registro. Entonces esa es la idea. |
| Entonces, |
| Tenemos |
| la capacidad de monitorear los guiones. Tenemos la capacidad de |
| capturar registros de accidentes. Entonces pensamos: ¿por qué no actuamos según el registro de fallos? Si ve un registro de fallos que significa que algo salió mal, y un script que... el usuario ya lo sabe porque el script falló obviamente, y el desarrollador sabe que el script falló porque los registros están |
| almacenado en un servidor. Así que están ahí para que usted pueda actuar en consecuencia. Pero la cuestión es que esto aún no es un circuito cerrado, porque el usuario no sabe que el desarrollador lo sabe. Y puedes cerrar ese círculo creando tickets automatizados. Entonces, como ya tienes la información, puedes |
| use un software de seguimiento de errores como JIRA Atlassian y luego podrá usar la funcionalidad REST |
| para recopilar la información del servidor, cree un ticket, asígnelo al desarrollador y también puede asignar al usuario como observador. El observador significa que cada vez que el desarrollador hace algo |
| sobre el error e ingresa esa información en JIRA, que se enviará al usuario para que se le notifique y sepa que alguien está trabajando en el error. |
| Y hay múltiples formas de hacerlo, dependiendo del tipo de JIRA que tengas, y solo te estoy dando la |
| código básico aquí. Es un código curl que puedes crear y recopilas los metadatos que tienes de los registros de fallos y los incrustas en un archivo JSL y luego se transmitirá a través de REST y entrará en el |
| JIRA, que es... que lo rastreará por usted. Y luego JIRA, si lo configura correctamente, JIRA lo notificará... JIRA notificará al desarrollador y posiblemente |
| el usuario para el cual... para quien el script falló. Y entonces todo esto está unido y el desarrollador sabrá que hay un error en el que necesita trabajar y el usuario sabrá que alguien estará trabajando en el error. |
| Bueno. Creo que esto me lleva a mis notas finales. Solo las conclusiones que puede obtener de esta presentación. |
| Git ha sido la piedra angular de nuestro sistema y nos ha permitido hacer muchas funciones interesantes y ni siquiera mencioné las básicas, que |
| que son bastante obvios, porque eso también te da la posibilidad de colaborar. Entonces, si hay varias personas trabajando en el mismo guión. Puedes utilizar todas las funcionalidades del |
