1
00:00:01,140 --> 00:00:05,200
En este video, me gustaría
mostrarle los

2
00:00:05,560 --> 00:00:09,520
análisis avanzados de código
que puede hacer con Nautilus.

3
00:00:10,260 --> 00:00:13,220
Entonces abramos Nautilus.
Consideramos por ejemplo

4
00:00:13,387 --> 00:00:14,670
una clase simple, NumberParser.

5
00:00:15,880 --> 00:00:19,090
Ahora miramos lo que

6
00:00:19,257 --> 00:00:20,170
llamamos Senders y
los Implementers

7
00:00:20,337 --> 00:00:24,640
A menudo, comprobamos si alguien
habla con fluidez en Pharo cuando

8
00:00:24,807 --> 00:00:27,350
ha entendido cómo
usar Senders y Implementers

9
00:00:27,517 --> 00:00:29,790
para encontrar información.
Echemos un vistazo: cuando

10
00:00:29,957 --> 00:00:31,770
considero un método,
Me gustaría saber quien

11
00:00:31,937 --> 00:00:33,620
llama a este método,
¿qué voy ha hacer?

12
00:00:34,080 --> 00:00:35,030
Utilizaré Senders Of.

13
00:00:36,680 --> 00:00:41,260
¿Qué obtendré con Senders Of?

14
00:00:41,427 --> 00:00:43,230
Solo tengo un método

15
00:00:43,397 --> 00:00:45,920
que llama a los Senders
Of, se llama

16
00:00:46,270 --> 00:00:50,560
ReadExponent y llama
ExponentLetters.

17
00:00:52,710 --> 00:00:54,310
Es una información interesante.

18
00:00:54,610 --> 00:00:56,810
Ahora imaginemos que voy
al protocolo

19
00:00:57,000 --> 00:01:01,830
publico, elijo
NextInteger. Si pregunto a los Senders,

20
00:01:03,140 --> 00:01:07,710
obtendré esta

21
00:01:08,420 --> 00:01:09,740
lista de Senders potenciales

22
00:01:10,810 --> 00:01:14,910
De hecho, son todos los lugares
que envían el mensaje NextInteger.

23
00:01:15,370 --> 00:01:17,310
Aquí veo que estoy en 
la clase

24
00:01:17,477 --> 00:01:20,590
NumberParser y que llamo
a self.

25
00:01:21,600 --> 00:01:24,180
Pues utilizo self para 
hacer una llamada y sera

26
00:01:24,347 --> 00:01:25,730
necesariamente el método que tengo aquí

27
00:01:26,740 --> 00:01:30,720
Ahora, en los paquetes
o en la clase XML, no se muestra

28
00:01:30,887 --> 00:01:33,360
porque necesariamente no lo conoce,
al ser Pharo

29
00:01:33,527 --> 00:01:36,370
un lenguaje no tipado,
No estoy seguro

30
00:01:36,537 --> 00:01:40,060
si este es el método en cuestión.

31
00:01:40,227 --> 00:01:44,020
De hecho, el sistema muestra
que un mensaje

32
00:01:44,187 --> 00:01:46,010
con el mismo nombre ha sido enviado.

33
00:01:46,720 --> 00:01:49,000
Para comprobar esto,
puedo, por ejemplo

34
00:01:49,167 --> 00:01:51,520
podria preguntarme,
digamos que me gustaría saber

35
00:01:51,950 --> 00:01:56,090
¿cuáles son los implementadores,
cuantas veces este

36
00:01:56,257 --> 00:01:57,650
método esta implementado en el
sistema.

37
00:01:57,817 --> 00:02:00,870
Para hacer esto, seleccionaré
Implementors Of.

38
00:02:02,520 --> 00:02:05,930
Implementors Of. Ah bah
mira, mientras en el otro

39
00:02:06,097 --> 00:02:08,350
caso solo tenía un método, por lo que
necesariamente era el que estaba

40
00:02:08,517 --> 00:02:12,290
llamado aquí, tengo varios de ellos

41
00:02:12,457 --> 00:02:16,050
Este método, NextInteger, esta
definido

42
00:02:16,217 --> 00:02:19,510
en NumberParser, pero también
esta definido en XMLInteger.

43
00:02:20,900 --> 00:02:24,420
XMLInteger esta incluso definido
en dos clases 

44
00:02:24,587 --> 00:02:26,950
diferentes, entonces veo que estos

45
00:02:27,117 --> 00:02:30,000
métodos, estas llamadas, son
llamadas de envío de

46
00:02:30,167 --> 00:02:34,030
mensajes y que se resolverán
seguramente sobre estos métodos.

47
00:02:34,420 --> 00:02:36,670
Puede ver que
Sender y Implementor son

48
00:02:36,837 --> 00:02:39,650
muy importantes.
Implementor, le permitirá

49
00:02:39,817 --> 00:02:41,710
ver todas las clases del sistema
que implementan un método.

50
00:02:41,877 --> 00:02:45,300
Sender le mostrara todas
las llamadas realizadas a un método.

51
00:02:45,467 --> 00:02:47,840
Entonces los Senders, son
muy importantes porque

52
00:02:48,007 --> 00:02:50,940
le permiten mirar
ejemplos,

53
00:02:51,107 --> 00:02:54,050
le mostrara cómo se invoca un método.

54
00:02:54,520 --> 00:02:56,920
Aquí he seleccionado un método
sin argumento,

55
00:02:57,087 --> 00:02:58,590
pero si hubiera elegido un método con
un argumento,

56
00:02:58,757 --> 00:03:02,650
por ejemplo Number,
NextNumberBase y entonces hago

57
00:03:02,817 --> 00:03:07,470
Sender, ¿Que va a 

58
00:03:07,637 --> 00:03:12,480
Mostrarme? Tengo un argumento,
y veo que es

59
00:03:12,647 --> 00:03:13,280
la base.

60
00:03:13,447 --> 00:03:15,050
Aquí parece que no es
un argumento,

61
00:03:15,217 --> 00:03:18,730
es solo una llamada que pasa un
argumento,

62
00:03:18,897 --> 00:03:22,030
pero en esta prueba aquí,
veo que

63
00:03:22,420 --> 00:03:27,340
si instancío
NumberParser en Stream,

64
00:03:28,340 --> 00:03:30,550
y que luego envío el mensaje
NextNumberBase

65
00:03:30,717 --> 00:03:32,930
y el argumento 10.

66
00:03:33,097 --> 00:03:35,030
Esto me permite comprender,
ah si, es así como

67
00:03:35,197 --> 00:03:36,200
debo usar la API.

68
00:03:37,000 --> 00:03:41,210
Se usa tanto dispone de
atajos de teclado.

69
00:03:42,390 --> 00:03:45,800
Nautilus fue diseñado en origen
Para que pueda

70
00:03:46,000 --> 00:03:48,550
hacer todas estas operaciones
sin tocar el mouse.

71
00:03:49,000 --> 00:03:51,260
Observe aquí que B significa
browse.

72
00:03:51,427 --> 00:03:55,890
Entonces haremos browse Sender,
N es para el sender.

73
00:03:56,057 --> 00:03:59,550
busco Implementor, M
es para Implementor.

74
00:04:00,440 --> 00:04:05,260
Si selecciono solo "NextNumber"
por ejemplo,

75
00:04:05,570 --> 00:04:08,780
y busco N, 
obtendré

76
00:04:11,110 --> 00:04:14,330
los Senders de NextNumber.

77
00:04:14,860 --> 00:04:17,740
De la misma manera, si selecciono,
voila, los obtengo

78
00:04:17,907 --> 00:04:19,610
Ahora si quiero obtener los
Implementors Browse M,

79
00:04:20,890 --> 00:04:22,160
Obtengo los implementors.

80
00:04:23,700 --> 00:04:25,650
Es igual sobre las clases,
me gustaría

81
00:04:25,817 --> 00:04:28,030
saber cuales son las otras clases
del sistema que utilizan 

82
00:04:28,197 --> 00:04:30,290
NumberParser.
Para saber esto,

83
00:04:30,457 --> 00:04:34,730
Yo selecciono Analize y
tengo Class

84
00:04:34,897 --> 00:04:39,820
references. Y obtengo todas

85
00:04:40,000 --> 00:04:43,380
las clases. Obtengo todos los métodos
que utilizan

86
00:04:47,300 --> 00:04:49,480
Aquí veo que son principalmente pruebas.

87
00:04:49,740 --> 00:04:53,000
Mira
en ClassInteger, llamo

88
00:05:00,130 --> 00:05:00,763
al Parser.

89
00:05:00,930 --> 00:05:05,440
Aquí, el consejo para entender
com recordar,

90
00:05:06,200 --> 00:05:09,300
el atajo de teclado,
es decirse que aqui es

91
00:05:10,050 --> 00:05:14,550
Browse shift N, es

92
00:05:16,070 --> 00:05:19,250
una mayúscula porque es
como

93
00:05:19,417 --> 00:05:21,700
llamar un método, excepto aquí
queremos

94
00:05:21,867 --> 00:05:24,090
llamar una clase y una clase
es mayor que

95
00:05:24,257 --> 00:05:25,310
un método, entonces tenemos una mayscula.