0:00:05.440,0:00:12.400
Así que hoy, soy Katie, y vamos a estar hablando de mi investigación que es en la búsqueda,

0:00:12.400,0:00:18.320
pero como somos desarrolladores estamos enfocando esto en no cualquier búsqueda, pero la búsqueda de código.

0:00:18.320,0:00:23.680
Así que la búsqueda de código es un término que estoy usando para describir el proceso de utilizar la búsqueda en un IDE,

0:00:23.680,0:00:28.240
en un navegador, en otra interfaz a medida, para localizar algún artefacto relacionado con el código.

0:00:28.960,0:00:35.440
Y hay muchas maneras - muchas interfaces que existen para la búsqueda de código.

0:00:35.440,0:00:40.160
La más común es el Google genérico, y todos lo hemos hecho.

0:00:40.160,0:00:44.960
Queremos un código de ejemplo, queremos saber cómo utilizar una API, queremos más información sobre algo 

0:00:44.960,0:00:49.680
relacionado con el código, como un mensaje de error, así que vamos directamente a Google, lanzamos una consulta textual y,

0:00:49.680,0:00:55.040
con suerte, encontramos el resultado entre los primeros resultados, las primeras consultas.

0:00:55.760,0:00:59.360
Hay otros tipos de interfaces que están aumentando su sofisticación.

0:00:59.360,0:01:06.640
Un ejemplo es el ecosistema de GitHub, tenemos una consulta textual aquí con varias formas - puedes

0:01:06.640,0:01:10.960
filtrar lo que quieres, si quieres un commit, si quieres un tema, si quieres una discusión,

0:01:11.520,0:01:16.400
y también formas de filtrar basadas en APIs de lenguaje, cosas así.

0:01:16.960,0:01:22.800
También fuera de GitHub en el espacio de búsqueda de código alejándose de la consulta textual, está entrando en

0:01:22.800,0:01:27.600
la consulta de comentario a código, o esto es Copilot de GitHub,

0:01:27.600,0:01:33.680
o un poco de búsqueda de código a código aquí.
Y luego también hay un montón de interfaces

0:01:33.680,0:01:37.280
que están dentro de IDEs dentro de las empresas específicas esta es una que es similar a,

0:01:38.240,0:01:43.040
por ejemplo, la búsqueda de Google - herramienta de búsqueda de código que existía hace varios años.

0:01:43.040,0:01:48.240
Así que la búsqueda de código resulta que sucede todo el tiempo, e hicimos un estudio de los desarrolladores

0:01:48.240,0:01:53.200
en Google, y resulta que ocurría 12 veces por desarrollador por día.

0:01:53.200,0:01:57.520
Y esto puede no parecer mucho, excepto que cuando estoy hablando de 12 veces al día, me refiero

0:01:57.520,0:02:02.160
sessions, and each - not individual query.
So a search session involves

0:02:02.160,0:02:07.840
a las sesiones de búsqueda, y cada - no a la consulta individual.
Así que una sesión de búsqueda implica

0:02:08.400,0:02:13.680
un promedio de tres a cuatro consultas, un montón de clics, algo de navegación, muchos minutos, es más que una sola búsqueda, y esto significa que está tomando mucho tiempo.

0:02:14.320,0:02:18.480
Y luego, cuando examinamos las herramientas específicas de Google, es decir,

0:02:18.480,0:02:26.320
la búsqueda genérica de información en Google, y segmentamos los registros de búsqueda en función de la búsqueda sin código 

0:02:26.320,0:02:30.800
y la búsqueda con código, resultó que las consultas de búsqueda con código requerían más tiempo, más clics 

0:02:30.800,0:02:36.000
y más reformulaciones, lo que significa más esfuerzo.
Y cuando analizamos las cosas que requieren

0:02:36.000,0:02:40.160
más esfuerzo, significa que hay una oportunidad para mejorar el soporte.

0:02:41.840,0:02:47.360
En nuestra investigación sobre la búsqueda de códigos, descubrimos que hay cuatro necesidades distintas

0:02:47.360,0:02:50.080
que surgieron como las más comunes.
Así que quiero hablar de ellas.

0:02:50.960,0:02:56.000
Una de ellas -la razón más común por la que los desarrolladores buscaban- eran las preguntas Cómo.

0:02:56.000,0:03:00.800
Cómo puedo utilizar esta API, puedo tener algún código de ejemplo que me muestre cómo hacer algo.

0:03:00.800,0:03:04.720
Se trata de un tercio de las búsquedas.
Y obtuvimos esta información encuestando

0:03:04.720,0:03:07.600
a los desarrolladores mientras utilizaban las herramientas de búsqueda de código.

0:03:09.120,0:03:15.120
El segundo tipo de pregunta más común era una pregunta Qué: ¿qué hace este código?

0:03:15.120,0:03:18.240
Una especie de pregunta de comprensión.
Y esto es aproximadamente una cuarta parte de las veces.

0:03:18.960,0:03:21.440
A veces se puede responder con comentarios, a veces no.

0:03:22.960,0:03:26.880
En qué parte de la base de código se encuentra algo, esto es una pregunta de localización,

0:03:26.880,0:03:29.520
tengo este mensaje de error y quiero saber de dónde viene.

0:03:30.160,0:03:36.400
Eso es alrededor del 16 por ciento de las búsquedas.
Y luego las preguntas por qué: por qué está

0:03:36.400,0:03:42.880
sucediendo algo fue otro 16 por ciento.
Así que quiero centrarme aquí al principio en

0:03:42.880,0:03:46.240
estas preguntas de Cómo, porque es la mayoría de las preguntas.

0:03:48.240,0:03:50.480
Así que cuando tienes una pregunta de Cómo, normalmente tienes 

0:03:50.480,0:03:56.080
algo de información y quieres algo de información.
Con nuestras herramientas actuales, a pesar de Copilot,

0:03:56.080,0:04:01.040
normalmente tenemos una consulta textual o formulamos nuestra pregunta como una consulta textual,

0:04:01.040,0:04:06.880
pero lo que realmente podríamos querer es un código de ejemplo.
Otro - y esto es bien - esto es bien soportado 

0:04:06.880,0:04:08.640
hoy en día.
Otro

0:04:10.080,0:04:19.200
método de búsqueda de código de ejemplo podría ser tener una función como tu consulta y

0:04:19.200,0:04:24.560
quieres una función como tu resultado.
Esto sería una búsqueda de código a código.

0:04:24.560,0:04:27.520
Esto puede ser útil en la educación si estás buscando implementaciones

0:04:27.520,0:04:32.480
alternativas del mismo algoritmo.
También puede ser útil para aprender un

0:04:32.480,0:04:37.760
nuevo lenguaje de programación o hacer una traducción.
Aquí tenemos un ejemplo de traducción: tenemos una

0:04:37.760,0:04:45.120
consulta en un lenguaje y un resultado en otro.
Así que para facilitar la búsqueda de código a código,

0:04:45.120,0:04:48.480
se requiere - especialmente a través de los lenguajes - un análisis

0:04:48.480,0:04:53.840
independiente del lenguaje.
Así que lo ideal es que exista una caja misteriosa -me

0:04:53.840,0:04:58.960
encantaría que existiera esta caja misteriosa- en la que la entrada es una consulta,

0:04:59.600,0:05:05.200
y lo que sale es un código que se comporta igual, en el mismo lenguaje, tal vez en otro lenguaje,

0:05:05.200,0:05:09.840
y en realidad lo más ideal es que no sea sólo un resultado, sino que sean muchos resultados.

0:05:10.400,0:05:16.080
Así que esto es lo que la búsqueda de código a código podría ser en un entorno ideal, donde tenemos

0:05:16.800,0:05:22.240
el análisis multilingüe y somos capaces de decir, este comportamiento es el mismo que este otro comportamiento.

0:05:22.960,0:05:28.000
Pero para hacer esto precisamente debemos tener garantías - debemos garantizar que para cualquier dos bloques de código

0:05:28.000,0:05:34.080
se comportan igual y por lo tanto terminan.
Y así nos encontramos con el Problema de la Parada.

0:05:35.600,0:05:41.360
Así que, de hecho, si queremos que la búsqueda de código a código sea precisa, nunca funcionará en teoría, pero hay

0:05:41.360,0:05:46.320
algunas pruebas de que puede funcionar en la práctica.
Así que esto es lo que hemos estado haciendo.

0:05:48.160,0:05:52.320
En la búsqueda de código a código, tenemos un montón de código fuente a nuestra disposición.

0:05:52.960,0:05:56.640
Hemos tenido un montón de conversaciones hoy en la minería GitHub, que es donde nos dirigimos.

0:05:57.440,0:06:01.600
Y digamos que tenemos un montón de fragmentos, y estos fragmentos todos existen en GitHub,

0:06:01.600,0:06:07.520
y tienen algunas - tienen algunas similitudes - por lo que hay - por lo que hay tres lenguajes 

0:06:07.520,0:06:12.480
que están representados aquí, algunos de ellos tienen similar

0:06:12.480,0:06:17.040
tienen el mismo comportamiento, otros tienen comportamientos similares, y bajo algunas entradas se comportan igual, bajo otras entradas se comportan de manera diferente,

0:06:18.000,0:06:23.680
y luego tenemos otros, como, dependiendo de cómo se divide, el comportamiento también puede ser el mismo.

0:06:24.880,0:06:30.400
Y luego también tenemos la similitud a través de la estructura.
Así que con todos estos niveles de similitud,

0:06:31.600,0:06:37.120
somos capaces de trazar paralelismos entre las diferentes áreas del código fuente y explotar estas 

0:06:37.120,0:06:43.280
similitudes para crear una búsqueda efectiva.
Lo que hicimos fue tomar el código fuente e

0:06:43.280,0:06:49.200
indexarlo utilizando tres dimensiones diferentes para crear un análisis de similitud multidimensional.

0:06:49.200,0:06:54.640
Usamos tokens o contexto porque la gente puede escribir código con cualquier nombre de variable que quieran,

0:06:54.640,0:06:58.320
pero resulta que tienden a hacerlo de una manera bastante natural, y podemos usar esa información.

0:06:59.040,0:07:04.480
Tomamos el comportamiento utilizando fuzzing, y tomamos la estructura utilizando un lenguaje agnóstico

0:07:04.480,0:07:09.040
AST - abstracto - árbol de sintaxis abstracto.
Y combinamos todo eso en un

0:07:09.040,0:07:13.680
análisis multidimensional utilizando la ordenación no dominante, así que dada una consulta

0:07:13.680,0:07:19.600
obtuvimos un montón de código similar, y fue bueno.
Los resultados eran de muy alta precisión, funcionaba

0:07:19.600,0:07:24.880
exactamente como queríamos excepto en una dimensión:
era terriblemente lento.

0:07:26.320,0:07:31.040
Y... y entonces tuvimos que volver a la mesa de dibujo, porque era tan lento que no era práctico.

0:07:31.760,0:07:35.280
Bueno, resulta que como la gente escribe el código de forma natural podemos aprovechar los patrones.

0:07:36.000,0:07:39.120
Así que cuando reemplazamos nuestro lento algoritmo con algo realmente

0:07:39.120,0:07:44.800
súper rápido para el aprendizaje automático y las incorporaciones,
tenemos que eliminar la pieza de comportamiento a comportamiento,

0:07:44.800,0:07:48.640
pero resulta que no importa, porque lo que tenemos aquí es un 

0:07:49.280,0:07:56.000
enfoque rápido para la búsqueda de código a código sin una pérdida de precisión, y eso es debido a 

0:07:56.000,0:08:00.160
los patrones que existen en el código fuente.
Así que la búsqueda de código a código está llegando 

0:08:01.360,0:08:06.800
y nos ayuda a responder a una de estas necesidades - nos ayuda a responder a las preguntas sobre el cómo.

0:08:07.840,0:08:11.840
Pero hay otras preguntas que los desarrolladores se hacen, y utilizan la búsqueda para

0:08:12.480,0:08:16.240
explicarlas: preguntas Qué, preguntas Dónde y preguntas Por qué.

0:08:18.240,0:08:21.200
Y la búsqueda de código no es buena para todas estas necesidades.

0:08:21.200,0:08:25.840
La búsqueda de códigos es un martillo y no todas estas preguntas son un clavo.

0:08:26.720,0:08:30.960
Así que vamos a ver uno por uno.
Entonces con el código de ejemplo, queriendo saber

0:08:30.960,0:08:35.360
preguntas Cómo, esto se puede hacer en la práctica con la búsqueda que ya has hecho por ti mismo con GitHub,

0:08:35.360,0:08:38.320
con Google, te he mostrado cómo se puede hacer con la búsqueda de código a código

0:08:38.320,0:08:43.280
un nuevo tipo de modalidad de búsqueda.
Si quieres hacer Qué, si quieres hacer preguntas de respuesta a

0:08:43.280,0:08:47.120
Qué, una cuarta parte de las veces son preguntas de comprensión de código, esto no es una búsqueda.

0:08:47.760,0:08:52.240
Y, de hecho, si le preguntas a tu motor de búsqueda qué hace tu código,

0:08:52.880,0:08:56.800
le estás pidiendo que te diga algo sobre el código -que te cuente una historia sobre el código que

0:08:56.800,0:09:02.240
podría no ser cierta- y, por lo tanto, estás asumiendo cierto riesgo y te

0:09:02.240,0:09:06.400
estás permitiendo un posible malentendido, por lo que probablemente no sea la mejor pregunta para hacer con un buscador.

0:09:06.960,0:09:10.240
Las preguntas Dónde en el IDE, hablando de la navegación de código,

0:09:10.240,0:09:14.160
esto es naturalmente apoyado, pero las preguntas por qué:

0:09:14.160,0:09:18.160
 cuando estamos hablando de por qué el código se comporta de esta manera, estamos hablando de la causalidad,

0:09:18.160,0:09:23.520
estamos hablando de análisis de impacto, y tal vez la prueba causal de Brittany Johnson podría ser

0:09:23.520,0:09:30.800
un mejor enfoque para ese tipo de preguntas.
Así que debido a estas situaciones de búsqueda de código,

0:09:30.800,0:09:35.200
donde la búsqueda de código no es necesariamente la herramienta adecuada para la pregunta, ocurre en el 40 por ciento de

0:09:35.200,0:09:40.400
las preguntas basadas en los datos que estudiamos, es realmente importante saber por qué estás buscando.

0:09:41.680,0:09:44.960
La búsqueda de código se realiza 12 veces al día, lleva mucho tiempo,

0:09:44.960,0:09:50.560
lleva muchas consultas, así que si estás preguntando cómo o dónde, la búsqueda de código es tu amiga.

0:09:51.440,0:09:56.320
Si quieres hacer una pregunta de qué -qué hace el código- 

0:09:56.320,0:09:58.960
probablemente no te convenga empezar por el buscador.

0:09:58.960,0:10:02.320
Es mejor que llames por teléfono a un amigo y le pidas que te ayude a programar en pareja.

0:10:03.760,0:10:08.160
Las preguntas de por qué es mejor replantearlas empezando por el dónde, que se responde más naturalmente

0:10:08.160,0:10:11.840
con el motor de búsqueda.
Así que la búsqueda de código no va a desaparecer.

0:10:11.840,0:10:17.200
Hay muchas - puede haber muchas maneras en el futuro para responder a estas preguntas qué y por qué con

0:10:17.200,0:10:27.040
más investigación, así que manténgase atentos a esto.
Gracias por escuchar.