| Vocero |
Transcripción |
| Serkay Olmez |
Hola, somos Serkay y Fred de Seagate y hoy vamos a hablar sobre cómo construimos un ecosistema JSL para administrar nuestros scripts JSL. |
| |
Usamos Git para gestionar los controles de código fuente, el código fuente de nuestros scripts JSL, así como para distribuirlos. Ese será el tema principal de la charla de hoy. |
| |
Además, también hablaré sobre VBA para la integración con PowerPoint, la recopilación de registros de fallos y las pruebas unitarias. Pasaré rápidamente al esquema. |
| |
Primero, quiero hablar sobre nuestra historia con JSL. Llevo unos 10 años desarrollando scripts en JSL. |
| |
Y estamos muy contentos con dónde estamos ahora, pero nos llevó bastante tiempo llegar hasta aquí y quiero hablar sobre los hitos de nuestra experiencia, lo que hicimos hasta ahora y por qué lo hicimos. |
| |
Luego hablaremos de Git y de cómo lo habilitamos para controlar el código fuente de nuestros scripts JSL y cómo nos permitió desarrollar nuevas funciones. Por ejemplo, una vez que habilitas Git, |
| |
Puedes agregar más funciones, como la monitorización de tus scripts. Así, los desarrolladores sabrán que sus scripts están en uso y podrán monitorizar su uso. |
| |
Y, probablemente más importante, también pueden recopilar registros. Si el script falla, el desarrollador lo sabe y puede corregir esos errores. Y tú puedes... |
| |
Puedes añadir una función más que va un paso más allá. Incluso puedes crear tickets de error automatizados si ya sabes que tu script falló. Así, puedes crear automáticamente un ticket de error para ese caso. Y puedes hacer seguimiento de esos tickets con un software de seguimiento como JIRA o Atlassian. |
| |
Y terminaré con nuestras mejores prácticas y lecciones aprendidas hasta ahora. |
| |
Entonces, |
| |
En el apéndice también tengo el manual de un script del que hablaré. Es un script que permite subir imágenes a PowerPoint. |
| |
Y tengo un manual muy detallado para eso, y debo informarle que todo lo que hablo aquí, los datos y los scripts estarán disponibles. |
| |
Están publicados en un repositorio público en la sección de referencias, y puedes acceder a ellos si lo deseas. Para empezar, |
| |
Con la breve historia aquí. Llevo trabajando con JSL unos 10 años y empecé... empecé con... |
| |
Muy básico y realmente no sabía mucho sobre scripts JSL. |
| |
Y luego, cuando empiezas a hacer eso, te das cuenta de que necesitas tener un control de código fuente adecuado y formas adecuadas de distribuir tus scripts. |
| |
Lo bueno de los scripts de JMP es que no tienen ninguna barrera de entrada. Así que puedes crear un gráfico manualmente y luego descargar el script. Está escrito para ti. |
| |
También puedes usar Comunidad JMP en JMP.com para hacer preguntas y obtener respuestas. |
| |
Y tú... el guion es tan eficiente que haces tu trabajo con tanta eficiencia que la gente lo notará. Te preguntarán cómo haces las cosas y dirás: «Tengo un guion para eso». Y ellos... |
| |
Pregunto: "¿Puedes compartir eso conmigo?". Y de repente te conviertes en desarrollador, aunque no era tu intención. |
| |
Y luego tienes que lidiar con la distribución de tus guiones. Lo primero que se me ocurre es simplemente adjuntarlos, lo cual es una idea horrible, y lo he hecho durante bastante tiempo. |
| |
Y es bastante obvio por qué eso 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 volver a enviarla, y ni siquiera sabes si el usuario aceptará la siguiente. Así que solo estoy ilustrando el punto. |
| |
Recientemente, recibí un correo electrónico de un colega y se refería a un guion que creé en 2017 y simplemente estaba numerando mis guiones con estos |
| |
Números de versión, lo cual no es buena idea. Así que regresa después de tres o cuatro años y te das cuenta de que la gente sigue usando un script de hace tres años, porque no lo actualizaron. |
| |
Una forma de resolver este problema es usar una unidad compartida y, en función de la interacción que tuve con las personas en ellas, |
| |
Discovery Summits, es que muchas personas, muchas empresas, lo están usando. Entonces, lo que hacen los desarrolladores es... |
| |
Vuelcan sus scripts en una unidad compartida y los usuarios los extraen directamente de ella, lo que resuelve la mitad del problema de distribución, pero no afecta el control del código fuente. No se pueden rastrear los cambios realizados en el código. |
| |
Y por eso nos migramos a Git. Fue un gran avance para nosotros y nos permitió acceder a muchas funciones. Entonces, ¿qué hace Git? Los desarrolladores suben sus scripts a un repositorio y... |
| |
Los usuarios obtendrán sus scripts directamente de Git. Esto supuso una gran mejora para nosotros y nos permitió recopilar registros de fallos y... |
| |
Uso de los scripts, etc. Y solo quiero hablar de un par de cosas más que aprendí en las Cumbres. Me han sido muy útiles para mejorar mis habilidades de scripting. Asistí a una cumbre en 2018 y aprendí bastante sobre expresiones, etc. |
| |
La gente podría querer volver atrás y escuchar esas presentaciones, porque ayudan con las habilidades de redacción de guiones. |
| |
Otro hito para nosotros fueron las pruebas. Me inspiró una charla en la Cumbre del año pasado, que trataba sobre las pruebas unitarias, que permiten probar automáticamente los scripts antes de publicarlos. |
| |
Hoy hablaré principalmente sobre pruebas de integración porque las pruebas unitarias son... pruebas unitarias son necesarias, pero no suficientes. |
| |
Como puedes realizar una prueba unitaria, puedes probar todos tus módulos y funcionan correctamente. Pero al ensamblarlos, no funcionarán. Se bloquearán, como se muestra aquí. Probablemente se prueba cada cajón, pero al ensamblarlos, no funcionarán. |
| |
Una característica interesante que ayuda bastante al desarrollador es la recopilación de registros. |
| |
Es muy útil saber que tu script falló y cómo. Puedes hacerlo recopilando los registros de los usuarios y revisando el script, implementando los cambios. Los usuarios recibirán su script corregido de inmediato. |
| |
Y la última función que estamos implementando recientemente se trata de los informes de errores automatizados. Dado que ya tienen el informe de fallos, ¿por qué no actuar en función de esa información? Así que creamos un sistema automatizado... |
| |
escucha |
| |
Sistema que registrará los registros de fallos y generará informes de errores automáticamente para que el desarrollador pueda trabajar en ellos. Además, se puede agregar al usuario como observador para que sepa que alguien está trabajando en el problema. Esto resuelve el problema. |
| |
que resuelve la brecha de información entre el usuario y el desarrollador. |
| |
Así que esto muestra la línea de tiempo y pasaré algún tiempo en ella. |
| |
en los elementos individuales, pero comenzaremos con Git y lo construiré rápidamente y dejaré que Fred hable sobre esto. |
| 163084 |
Bueno. |
| |
Entonces, |
| |
Git es simplemente un sistema de control de versiones, y no uso la palabra "control de versiones". De hecho, quiero decir que Git te ayuda brindándote, en efecto, rehacer sin límite, incluso si solo lo usas en tu computadora local. |
| |
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. |
| |
Git es simplemente un software que se instala en el equipo local. Crea un repositorio, que luego puede publicarse en otros repositorios. |
| |
Como GitLab o GitHub. TortoiseGit es una interfaz gráfica de usuario (GUI) para acceder a tu equipo local que facilita las cosas. Serkay, ¿podrías pasar a la siguiente diapositiva? |
| |
Así que el modelo que he intentado que los desarrolladores usen es en su computadora local. Los desarrolladores en local, les piden que instalen el cliente Git e inicien... |
| |
Control de versiones de 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 al repositorio remoto. Una vez que esté en el repositorio remoto, estará disponible para que un servidor web HTTP la comparta y JMP... |
| |
Luego, podemos apuntar a las URL y al servidor web HTTP...HTTP y cargar scripts desde él. 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, los puntos que aparecen a continuación simplemente señalan los beneficios de eso y cómo funciona exactamente. |
| |
Podemos pasar a la siguiente diapositiva. |
| Serkay Olmez |
Entonces yo tomaré el control aquí, Fred, y te mostraré... te mostraré una implementación de ilustración muy básica, y los scripts están disponibles en las Referencias. |
| |
Entonces, |
| |
Este será un código muy básico. Y lo que muestro aquí es el código que el desarrollador está desarrollando. 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 proporcionarlo, lo que el desarrollador pasa es este código, |
| |
Este es un enlace al repositorio. Este es el repositorio del script JSL "hola" que se encuentra ahí... |
| |
en el repositorio remoto. Lo que hace el usuario es simplemente tomar... el usuario toma el... |
| |
Script de la URL. Este es código estático. No necesita cambios, así que el desarrollador puede cambiar el script cuando quiera, pero el usuario no tiene que hacer nada. Les mostraré una ilustración aquí y quiero verlo en pantalla completa. |
| |
Simplemente ilustra cómo funciona esto con una interfaz gráfica específica, que es GitHub Desktop. Lo que tienes que hacer es instalar esto. |
| |
Software en tu computadora y crea un repositorio local. Este registrará los cambios que hayas realizado. Por ejemplo, en este caso, acabo de crear este script JSL de "hola". |
| |
Este software detectará un cambio y lo resaltará automáticamente. Primero, lo confirma en su repositorio local. |
| |
Esto envía esos datos a tu repositorio local y luego los envías al origen, que es un repositorio remoto. Ahora los enviaré al repositorio remoto, lo que los pondrá a disposición de los usuarios. |
| |
Una vez hecho esto, los usuarios podrán extraer este nuevo código. Vuelvo al rol de usuario y este script se ejecuta. Al hacerlo, aparecerá el cuadro de diálogo. Así que se ejecuta el script que se extrajo del repositorio. |
| |
Así que lo ilustraré... lo ilustraré un poco mejor con un código más avanzado, que también estará relacionado con PowerPoint. |
| |
La gente realiza muchos análisis en JMP, y muchos, al final, aún quieren enviar sus resultados a PowerPoint. Sé que JMP tiene algunas capacidades para... |
| |
imágenes directamente a PowerPoint, pero queríamos algo más... algo un poco más sofisticado. Queremos... |
| |
Administrar la plantilla de PowerPoint. Queremos hacer más cosas dentro de PowerPoint: decidir cuántas imágenes queremos poner por diapositiva, etc. |
| |
Para hacer eso, primero debes conectar JMP con PowerPoint y puedes hacerlo muy fácilmente. |
| |
De una forma muy eficaz, sin necesidad de salir de JMP. Lo que puedes hacer es localizar el archivo ejecutable de PowerPoint, que suele estar en Archivos de programa. |
| |
Luego, crea un archivo por lotes que activará este ejecutable de PowerPoint, el cual tomará el archivo de PowerPoint que desea ejecutar y lo ejecutará. Todo esto se puede hacer en JMP. Básicamente, busca el archivo ejecutable de PowerPoint. |
| |
Una vez que lo localiza, lo agrupa en este archivo por lotes. También incluye la ruta a la presentación de PowerPoint que desea ejecutar. |
| |
Y la macro, y por lo tanto PowerPoint tendrá una macro para gestionarla. Así es como... |
| |
Si vinculas JMP a PowerPoint, tendrás que dejarlo. Pero la pregunta es, ¿cómo haces llegar este archivo de PowerPoint a tus usuarios? Podrías... |
| |
Pídele que lo descargue, lo cual no es ideal, ya que quieres gestionarlo automáticamente y, al mismo tiempo, controlar el código fuente de tu PowerPoint. Por lo tanto, debe ser un buen candidato; debe ser una buena parte de todo el ecosistema. No quieres que quede fuera. |
| |
Otro requisito es no descargar PowerPoint cada vez que se ejecuta el script. Por lo tanto, solo se debe descargar si ha cambiado en el repositorio de imágenes o si hay alguna novedad. |
| |
Una forma de hacerlo es usar este pequeño script JMP, un comando JMP que indica la fecha de creación. Lo que estoy haciendo aquí es comprobar... |
| |
La fecha del archivo local. Por lo tanto, si la presentación de PowerPoint local es anterior a la que tengo en el repositorio, la descargaré. |
| |
Irá y descargará la presentación de PowerPoint mediante una solicitud HTTP y... |
| |
Se ve algo así. Lo que tienes que hacer es revisar tu PowerPoint en tu computadora local. Si no existe, puedes obtenerlo del repositorio mediante una solicitud HTTP. Si existe, puedes revisar su fecha, y si es antiguo, también puedes... |
| |
Extrae el nuevo. En resumen, puedes integrar PowerPoint sin problemas en el entorno JMP, lo que te permite importar tus resultados a JMP, incluyendo tablas e imágenes. Todo esto sin interrumpir el control de código fuente. Aquí te mostraré una demostración. |
| |
Este será el código que, por ejemplo, les darías a tus usuarios. De nuevo, es código estático. No contiene nada más que una URL que enlaza al repositorio remoto en el script. Así que tomará... |
| |
Script JMP del repositorio y esos scripts están nuevamente disponibles y puedes obtenerlos de las Referencias. |
| |
Desde el punto de vista del desarrollador, este es el script real, ¿verdad? Este es el script que el desarrollador ha desarrollado y... |
| |
Lo envía al repositorio remoto. Lo bueno de este script es que quiero destacar brevemente un par de características. |
| |
Por ejemplo, si observa esto, es un script de texto independiente y no necesita distribuir archivos de PowerPoint ni scripts adicionales. |
| |
Por separado. Lo que haces es vincularlos en tu script y se vinculan en el repositorio aquí. |
| |
Incluyendo PowerPoint. Este script gestionará toda la distribución. Capturará PowerPoint. |
| |
Tomará otros archivos adicionales si es necesario. Así que todo está agrupado en el script, lo que permite que se encargue de toda la gestión. Permítanme mostrarles esto rápidamente. Lo recuperaré. |
| |
y ponerlo en pantalla completa |
| |
Para que puedas verlo con claridad. Esta será una demostración de cómo activar PowerPoint automáticamente. |
| |
Para un caso particular. Este script obtiene las rutas de la tabla JMP que incluye muchas rutas de imágenes, y estas se refieren a este caso en particular. |
| |
servidor, y tomará esas rutas y solo tomará las resaltadas aquí y las enviará a PowerPoint. |
| |
Simplemente ejecutaré esto y este script está disponible para que lo pruebes. Es un script útil y completamente funcional. Así que, lo estoy ejecutando. |
| |
script aquí. Nuevamente, se refiere al repositorio. Por lo tanto, no tiene el script de fila; simplemente lo extrae del repositorio. Lo ejecutas, recupera el código y abre un diálogo. |
| |
Simplemente lo ejecutaré. No entraré en detalles. Una vez que lo ejecutes, se activará automáticamente la presentación de PowerPoint. |
| |
PowerPoint se iniciará y... está comenzando... está creando las diapositivas. Extraerá 20 imágenes y esto tomará 10 o 20 segundos y luego tendrás la presentación de PowerPoint. |
| |
Listo. Este es el PowerPoint que obtienes. Todo se hace automáticamente y todo se extrajo del repositorio. |
| |
¿Y ahora qué? ¿Cómo revisarías esta presentación de PowerPoint? Supongo que quieres hacer algunos cambios en tu plantilla. |
| |
Puedes ver más detalles sobre esto en el apéndice, pero lo que quiero mostrar es cómo cambiar el |
| |
guion en PowerPoint. Y lo mostraré en pantalla completa. |
| |
Y simplemente ejecutaré esto. Empezamos con lo que nos quedó de la diapositiva anterior, ¿cierto? Tenían estas imágenes. |
| |
Lo que quiero hacer es cambiar la plantilla de forma sencilla, solo para ilustrar el punto. Así que ve a... |
| |
Ve a la macro, desplázate hacia abajo y busca lo que quieres cambiar. Haré un cambio simple. Cambiaré el color del encabezado, solo para aclararlo. Cambia esto. |
| |
y |
| |
Guárdalo. Y esto es en tiempo real. |
| |
Puedes guardar esto y eliminar las diapositivas para que llegue más rápido al repositorio, porque estarás enviando esto al repositorio. |
| |
Luego, lo envías mediante la interfaz gráfica de Git. Se guardará en el repositorio. |
| |
Y lo pondrá a disposición de tus usuarios. Así, todos recibirán la modificación al instante. Así que no tendrás que pedirles que actualicen 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 vuelves a ejecutar, pasará por el |
| |
Diapositivas, se creará la diapositiva. Notarás que tienes los cambios, que se referían al cambio de color de la línea del encabezado. |
| |
Entonces, |
| |
¿Qué más tenemos? |
| |
Monitoreo de scripts. Creo que esta fue una de las mejores funciones que desarrollamos, porque le da al desarrollador la capacidad de ver si... |
| |
Su guion... el suyo, su guion, ¿se valora o no? Cierto. Entonces, ¿se publica? ¿Alguien lo publica regularmente? |
| |
Ese es un beneficio. El otro beneficio es... |
| |
registro... recopilación de registros de fallos. Si el script falla, puede capturar el fallo mediante la función de captura de registros de JMP. De esta forma, integra sus subrutinas en la captura de registros. |
| |
Si falla, el registro del fallo se devolverá en este texto devuelto. Y luego, lo que también haces es... |
| |
enciérrelo en un intento, para que el script aún sobreviva para realizar el informe. |
| |
Luego compruebas si está vacío. Si está vacío, significa que no hubo ningún fallo, por lo que tus scripts sobrevivieron. |
| |
Pero si no está vacío, significa que hubo un fallo y lo contuviste. Puedes obtener el registro y reportarlo. La forma de hacerlo es usar HTTP. |
| |
ID de usuario, el nombre del script y la nota de registro, si se trata de un fallo... |
| |
Ya sea un fallo o una ejecución normal, quizás se puedan obtener algunas métricas de rendimiento. En resumen, puedes transmitir algunos metadatos de tu script al desarrollador. |
| |
El servidor los registrará y tendrás un conjunto de archivos almacenados en el servidor que podrás monitorear. Les muestro un ejemplo. |
| |
Tabla de estos. Es un registro de fallos, que tiene... que tiene la marca de fecha, tiene un nombre de script, por lo que este script ha fallado en la fecha |
| |
Con este fallo en particular. Esto es extremadamente útil para el desarrollador, ya que puede volver atrás y solucionar el problema. Voy a contraer esto y esto y haré una demostración rápida que muestra cómo... |
| |
cómo tú |
| |
Contener el fallo y cómo informar al usuario. Lo que haré aquí es crear una subrutina que se bloquee. Crearé un parámetro indefinido. |
| |
Y JMP se quejará. Dirá que esto no está definido, por lo que el script se bloquea. Pero lo que haré será llamar a esa subrutina. |
| |
En una función de captura de registros, todo se intercalará bajo el intento. Por lo tanto, aunque el script falló con la subrutina, sobrevivirá y podrá informar... |
| |
Informe de fallos. ¿Le envías una notificación con un formato adecuado al usuario? Los scripts fallan con este error en particular, creamos un registro y estamos trabajando en ello. Esa es la notificación que le envías al usuario. |
| |
Una cosa clave que aprendí en las Cumbres fue sobre las pruebas automatizadas. Antes, solía hacer mis pruebas manualmente, lo cual es muy frustrante. |
| |
Porque lleva tiempo y no puedes capturar cada detalle de tu guion. Es imposible dedicar horas a pruebas cuando se hace un pequeño cambio. |
| |
Empecé a adentrarme en las pruebas automatizadas y es muy importante realizar pruebas unitarias. Las pruebas se refieren a probar subrutinas individuales. Por ejemplo, tienes una función y quieres probarla. |
| |
varias veces antes de ponerlo en su sistema general, para que pueda hacer estas pruebas unitarias |
| |
para módulos individuales, pero no será suficiente. Puedo mostrarles un par de ejemplos. |
| |
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 los EE. UU. Y uno de ellos trabajaba con las unidades de libras y el de, sí, ese era el de los EE. UU. y el de Europa. |
| |
Estaba usando Newtons. Así que hicieron sus pruebas unitarias. Pero cuando armaron su código, no funcionó, porque uno esperaba Newtons y el otro recibía libras. Así que literalmente perdieron... |
| |
Orbiter, simplemente porque olvidaron convertir de libras a Newtons. Y más recientemente, con 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, lo que cuenta es la |
| |
prueba de integración porque los módulos no viven solos en el script, hablan juntos. |
| |
Y esta es una ilustración curiosa del problema. Puedes tener dos objetos que se prueban a fondo. 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 se combinan, si funcionan bien juntos. |
| |
Quiero ilustrar brevemente cómo comencé a realizar pruebas automatizadas. Esto se referirá a un caso particular, que es... |
| |
Un caso difícil, para ser justos, porque se trata de una prueba de una ventana modal, y las ventanas modales no desaparecen a menos que hagas clic en un botón. Así que tienes que... |
| |
crear un script JMP que haga clic en un botón, que de alguna manera imite un comportamiento humano, y lo que estoy haciendo aquí es inyectar un probador en el |
| |
ventana modal aquí. Y lo bueno de este enfoque, creo, 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 hay alguna rutina de prueba en él. |
| |
Entonces, tiene los ganchos para un probador, pero luego lo ejecuta solo, lo que hace es buscar este parámetro de modo de prueba y no está configurado. |
| |
Si no está configurado, el script lo pondrá a cero, lo que deshabilitará todos los ganchos de la tabla. Puedes proporcionar esto a tus usuarios para que lo ejecuten así. |
| |
Sin embargo, si quieres probar tu script, lo que haces es crear un código de prueba sobre él. Este código establecerá el modo de prueba en uno y también creará el probador... |
| |
El objeto de prueba que desea inyectar en su script. Por ejemplo, en este caso, lo que hace es seleccionar una columna específica. |
| |
Y luego le asigna un rol haciendo clic en un botón y luego ejecuta el script. Eso imita literalmente el comportamiento humano. |
| |
Entonces cargará el script. Básicamente, inyectará los parámetros en el script que desea probar. Ahora, el script se ejecuta automáticamente, por lo que se cargará, se ejecutará y cerrará la interfaz de usuario después de hacer clic en uno u otro botón. |
| |
Y luego lo que haces es ejecutarlo nuevamente en una funcionalidad de captura de registro, de modo que sepas si algo sale mal, podrás capturar la falla. |
| |
Y también lo colocas en el intento de entrada para que, en general, el script sobreviva y reporte el registro. Y si no hubo ningún error, obtendrás un registro vacío, lo que significa que tu script no falló. |
| |
Si algo salió mal, lo sabrás en la captura de registro. Esa es la idea. |
| |
Entonces, |
| |
Tenemos |
| |
La capacidad de monitorear los scripts. Tenemos la capacidad de |
| |
Capturar registros de fallos. Así que pensamos: ¿por qué no actuar sobre el registro de fallos? Si ves un registro de fallos que significa que algo salió mal, y el script... el usuario ya lo sabe porque el script falló, obviamente, y el desarrollador sabe que el script falló porque los registros... |
| |
Se almacenan en un servidor. Así que están ahí para que puedas actuar sobre ellos. Pero el problema es que esto aún no es un ciclo cerrado, porque el usuario no sabe que el desarrollador lo sabe. Y puedes cerrar ese ciclo creando tickets automatizados. Así que, como ya tienes la información, puedes... |
| |
Utilice un software de seguimiento de errores como JIRA Atlassian y luego podrá utilizar la funcionalidad REST |
| |
Para recopilar la información del servidor, crear un ticket, asignarlo al desarrollador y también asignar al usuario como observador. El observador significa que, siempre que el desarrollador realiza alguna acción, |
| |
sobre el error e ingresa esa información en JIRA, que se enviará de vuelta al usuario para que este sea notificado y sepa que alguien está trabajando en el error. |
| |
Y hay varias formas de hacerlo, dependiendo de la versión de JIRA que tengas, y solo te estoy dando las |
| |
Aquí está el código básico. Es un código curl que puedes crear y que recopila los metadatos de los registros de fallos, los integra en un archivo JSL y luego se transmite a través de REST. |
| |
JIRA, que lo rastreará por ti. Y luego, si lo configuras correctamente, JIRA lo notificará... JIRA notificará al desarrollador y posiblemente... |
| |
El usuario al que le falló el script. Todo esto está conectado, y el desarrollador sabrá que hay un error en el que debe trabajar, y el usuario sabrá que alguien estará trabajando en él. |
| |
Bien. Creo que esto me lleva a mis notas finales. Solo las conclusiones que pueden sacar de esta presentación. |
| |
Git ha sido la piedra angular de nuestro sistema y nos ha permitido realizar muchas funciones interesantes y ni siquiera mencioné las básicas, que... |
| |
Lo cual es bastante obvio, ya que también te da la posibilidad de colaborar. Así que, si varias personas trabajan en el mismo guion, pueden usar todas las funcionalidades del... |
