1
00:00:00,790 --> 00:00:01,660
Hola y bienvenidos.

2
00:00:01,810 --> 00:00:05,680
Vamos a ver a continuación la ejecución paso a paso en nuestro IDE de Shinji.

3
00:00:05,920 --> 00:00:06,720
Están listos?

4
00:00:06,820 --> 00:00:07,330
Vamos.

5
00:00:08,530 --> 00:00:08,780
Bien.

6
00:00:08,800 --> 00:00:14,110
Una de las ventajas de trabajar con herramientas como en este caso el IDE de Shinji, es que podemos

7
00:00:14,110 --> 00:00:16,180
ejecutar paso a paso nuestro código.

8
00:00:16,330 --> 00:00:18,850
En este caso, les estamos agregando una animación.

9
00:00:19,240 --> 00:00:25,000
Observamos esta ventana del lado derecho en la cual vamos a agregar una animación de la ejecución paso

10
00:00:25,000 --> 00:00:30,070
a paso de nuestro código y podemos observar en primer lugar que tenemos nuestra memoria stack.

11
00:00:30,400 --> 00:00:33,140
Aquí es donde se va a almacenar la llamada de nuestras funciones.

12
00:00:33,160 --> 00:00:38,260
Podemos observar que tenemos la llamada de nuestra función principal y también aquí vemos cómo se van

13
00:00:38,260 --> 00:00:40,840
a ir definiendo y creando nuestras variables.

14
00:00:41,080 --> 00:00:45,750
Y recordemos que la memoria de Stack se llama precisamente Stack, porque vamos a ir agregando 1 a 1

15
00:00:45,760 --> 00:00:49,990
nuestros elementos conforme se vayan definiendo y ejecutando en nuestro programa.

16
00:00:50,440 --> 00:00:56,680
Así que ya sea llamadas a funciones o también creación de variables, se van a ir agregando como si

17
00:00:56,680 --> 00:00:57,640
fuera una pila.

18
00:00:57,940 --> 00:01:02,500
En este caso, esta pila podríamos decir que está en orden inverso, ya que normalmente una pila.

19
00:01:03,040 --> 00:01:04,540
Tenemos el primer elemento.

20
00:01:04,540 --> 00:01:09,520
El segundo elemento es decir, que se van apilando y conforme se van dejando de utilizar, entonces

21
00:01:09,520 --> 00:01:12,720
se van quitando según el orden en que se fueron apilando.

22
00:01:12,820 --> 00:01:16,090
En este mismo orden se van eliminando, pero de manera inversa.

23
00:01:16,360 --> 00:01:18,460
Así que esto sería básicamente una pila.

24
00:01:18,760 --> 00:01:22,840
Pero por la forma en que vamos a realizar nuestra animación, esos nuevos elementos se van a ir agregando

25
00:01:22,840 --> 00:01:28,540
hacia la parte inferior y conforme se van eliminando, entonces se van a ir retirando de nuestra memoria.

26
00:01:28,960 --> 00:01:31,060
Así que ese es el concepto de memoria stack.

27
00:01:31,270 --> 00:01:35,380
Y ya más adelante también vamos a ver en qué consiste el concepto de memoria IP.

28
00:01:35,650 --> 00:01:39,850
De momento este concepto de memoria no lo vamos a trabajar, pero también es otra sección de memoria

29
00:01:39,850 --> 00:01:43,420
que se utiliza sobre todo en lenguajes de programación orientada a objetos.

30
00:01:43,840 --> 00:01:49,390
El lenguaje de C es importante comentar que solamente soporta programación estructurada y no soporta

31
00:01:49,390 --> 00:01:51,010
la programación orientada a objetos.

32
00:01:51,880 --> 00:01:56,260
Ejemplos de lenguajes que soportan la programación orientada a objetos podría ser, por ejemplo en lenguaje

33
00:01:56,260 --> 00:02:02,460
de C++, el lenguaje de Java, C, Sharp, JavaScript, Python, etc Esos son otros lenguajes que sí

34
00:02:02,470 --> 00:02:04,420
soportan la programación orientada a objetos.

35
00:02:04,600 --> 00:02:09,370
Pero debido a que el lenguaje C es uno de los primeros lenguajes que se crearon, entonces este es únicamente

36
00:02:09,370 --> 00:02:10,750
un lenguaje estructurado.

37
00:02:11,020 --> 00:02:16,420
Esto quiere decir que nuestras instrucciones de código se ejecutan únicamente de manera secuencial,

38
00:02:16,660 --> 00:02:22,450
Así que por ello vamos a ir ejecutando 1 a 1 nuestras líneas de código desde la parte superior hasta

39
00:02:22,450 --> 00:02:23,680
la parte inferior.

40
00:02:24,280 --> 00:02:26,530
Y es precisamente lo que vamos a hacer en este ejercicio.

41
00:02:26,710 --> 00:02:29,350
Vamos a ejecutar paso a paso nuestro código.

42
00:02:29,860 --> 00:02:32,560
Así que tenemos nuestro código, Tenemos nuestra animación.

43
00:02:32,560 --> 00:02:38,020
Pero esta animación hemos comentado que no es parte de nuestro IDE, solamente es un apoyo visual para

44
00:02:38,020 --> 00:02:41,950
que podamos entender correctamente cada uno de nuestros ejercicios y esta animación.

45
00:02:41,950 --> 00:02:46,840
En la medida de lo posible, vamos a ir agregando a cada uno de los ejemplos que vamos a estar estudiando

46
00:02:46,840 --> 00:02:48,130
a lo largo de nuestro curso.

47
00:02:48,580 --> 00:02:54,040
Bien, para ejecutar paso a paso nuestro programa, lo primero que tenemos que hacer es poner un punto

48
00:02:54,040 --> 00:02:54,700
de ruptura.

49
00:02:55,000 --> 00:02:59,890
Por ejemplo, en la línea cinco, donde estamos definiendo nuestra variable, podemos agregar un punto

50
00:02:59,890 --> 00:03:05,440
de ruptura de la siguiente manera A este punto de ruptura también se le conoce como breakpoint en inglés.

51
00:03:06,010 --> 00:03:11,260
Así que para agregar un punto de ruptura, en este caso en la línea cinco, nos posicionamos entre el

52
00:03:11,260 --> 00:03:15,160
número cinco y esta barra gris que podemos observar que separa nuestro código.

53
00:03:15,370 --> 00:03:20,200
Así que si damos clic sobre la línea cinco en este espacio, entonces se agrega un punto de ruptura.

54
00:03:20,440 --> 00:03:23,890
Y para quitar este punto de ruptura, simplemente volvemos a dar clic.

55
00:03:24,220 --> 00:03:28,930
Ahora, un punto de ruptura, precisamente como su nombre lo indica, quiere decir que se va a detener

56
00:03:28,930 --> 00:03:33,130
la ejecución de nuestro programa en este momento, en este caso en la línea cinco.

57
00:03:33,460 --> 00:03:37,060
Y una vez que hemos agregado este punto de ruptura, tenemos este botón.

58
00:03:37,240 --> 00:03:42,970
Este botón nos permite hacer debug o lo que es lo mismo, ejecución paso a paso de nuestro programa.

59
00:03:43,270 --> 00:03:47,050
Así que vamos a hacer lo siguiente Una vez que hemos agregado el punto de ruptura, presionamos este

60
00:03:47,050 --> 00:03:48,250
botón de debug.

61
00:03:48,790 --> 00:03:49,780
Vamos a presionarlo.

62
00:03:50,470 --> 00:03:55,240
Nos indica que en este caso, la línea cinco no es una línea válida para agregar un punto de ruptura,

63
00:03:55,570 --> 00:04:00,760
ya que debe de ser, por ejemplo, una variable que se está declarando pero que además se está inicializando.

64
00:04:01,240 --> 00:04:06,790
Así que damos clic en OK, Vamos a asignar un valor a nuestra variable para que podamos agregar este

65
00:04:06,790 --> 00:04:07,720
punto de ruptura.

66
00:04:08,110 --> 00:04:11,560
Por ejemplo, le asignamos el valor de then de manera inicial.

67
00:04:11,830 --> 00:04:15,250
Volvemos a agregar nuestro punto de ruptura y volvemos a ejecutar.

68
00:04:15,940 --> 00:04:20,950
Y podemos observar que en este caso, ahora, si ya se ejecutó nuestro modo debug ya es una línea válida.

69
00:04:21,160 --> 00:04:25,570
Como hemos comentado, esta línea no era válida debido a que tenemos que llegar a este punto de ruptura

70
00:04:25,870 --> 00:04:30,610
en una línea donde estemos declarando una variable, pero además también le estemos asignando un valor.

71
00:04:31,080 --> 00:04:36,670
Bien, así que ya tenemos nuestro punto de ruptura y para poder ejecutar esta línea de código, tenemos

72
00:04:36,670 --> 00:04:37,630
el siguiente botón.

73
00:04:38,050 --> 00:04:42,910
En este caso, este botón se conoce como este hover, es decir, que solamente va a ejecutar esta línea

74
00:04:42,910 --> 00:04:43,450
de código.

75
00:04:43,660 --> 00:04:48,430
Pero si en esta línea se ejecutará alguna función, no vamos a entrar al detalle de la ejecución de

76
00:04:48,430 --> 00:04:49,300
dicha función.

77
00:04:49,300 --> 00:04:52,630
Solamente se va a ejecutar por completo esta línea de código.

78
00:04:52,900 --> 00:04:55,690
Así que para esto funciona este botón de este hover.

79
00:04:55,900 --> 00:05:00,220
Pero por ejemplo, en el método printf si quisiéramos entrar al detalle de este.

80
00:05:01,070 --> 00:05:05,630
Entonces, en lugar de este hover, presionaremos el botón de este pin.

81
00:05:05,930 --> 00:05:08,870
Esto para entrar al detalle de esta función de printf.

82
00:05:09,230 --> 00:05:12,410
Pero de momento solamente queremos ejecutar esta línea de código.

83
00:05:12,620 --> 00:05:18,260
Así que presionamos el botón de step over y entonces observamos que en este momento en memoria ya se

84
00:05:18,260 --> 00:05:21,020
ha creado nuestra variable llamada mi número.

85
00:05:21,230 --> 00:05:26,720
Estamos dentro del método main y ya se ha creado esta variable y se le está asignando el valor de then.

86
00:05:27,200 --> 00:05:31,550
Recordemos que además falta observar la dirección de memoria donde se encuentra esta variable.

87
00:05:31,730 --> 00:05:36,320
Esto lo vamos a ver posteriormente, pero de momento, de manera simplificada, tenemos el nombre de

88
00:05:36,320 --> 00:05:41,750
nuestra variable, tenemos su valor y además tenemos el tipo de dato que se está almacenando en esta

89
00:05:41,750 --> 00:05:42,260
variable.

90
00:05:42,410 --> 00:05:47,630
Recordemos que al momento de definir nuestra variable hemos especificado que va almacenar un valor de

91
00:05:47,630 --> 00:05:48,470
tipo entero.

92
00:05:49,490 --> 00:05:53,560
Y ahora, si volvemos a ejecutar nuestro programa, presionamos de nueva cuenta este hover.

93
00:05:53,690 --> 00:05:55,670
No necesitamos entrar al detalle en nuestra función.

94
00:05:56,390 --> 00:05:58,610
Simplemente queremos mandar a imprimir este valor.

95
00:05:58,850 --> 00:06:04,040
Así que mandamos a imprimir de nueva cuenta presionando el botón de este hover y podemos observar en

96
00:06:04,040 --> 00:06:06,620
nuestra salida, en nuestra consola, el valor de diez.

97
00:06:06,980 --> 00:06:11,120
Así que ya se está imprimiendo precisamente este valor que hemos asignado a nuestra variable.

98
00:06:11,300 --> 00:06:16,730
Se está recuperando, lo estamos leyendo y se manda a imprimir este valor debido a que estamos ejecutando

99
00:06:16,730 --> 00:06:18,680
la línea seis de nuestro código.

100
00:06:19,400 --> 00:06:23,060
Ahora, en la línea ocho, simplemente lo que estamos haciendo es volver a asignar un valor.

101
00:06:23,240 --> 00:06:29,570
Vamos a presionar este hover se manda a imprimir de nueva cuenta este valor debido a que no se ha modificado

102
00:06:29,570 --> 00:06:34,970
el valor inicial de diez es el valor que se vuelve a mandar imprimir y podemos llevar que ahora estamos

103
00:06:34,970 --> 00:06:36,530
ejecutando la línea 14.

104
00:06:36,800 --> 00:06:40,820
Esta línea 14 lo que va a hacer es modificar el valor de la variable mi número.

105
00:06:41,060 --> 00:06:47,270
Así que volvemos a ejecutar y entonces en nuestra animación podemos ver que en este momento, si ya

106
00:06:47,270 --> 00:06:53,260
se ejecutó la línea 14, entonces quiere decir que el valor que tenía nuestra variable en lugar de diez.

107
00:06:53,270 --> 00:06:55,100
Ahora ya tenemos el valor de 20.

108
00:06:56,350 --> 00:07:00,190
Por lo tanto, si ejecutamos la línea 15, volvemos a ejecutar.

109
00:07:00,910 --> 00:07:07,540
Se imprime ahora el valor de 20, así que estamos recuperando de la memoria el valor almacenado por

110
00:07:07,540 --> 00:07:10,360
esta variable y se manda a imprimir el valor de 20.

111
00:07:11,050 --> 00:07:13,870
Y básicamente esta es la última línea de código de nuestro programa.

112
00:07:14,110 --> 00:07:19,540
Ya la siguiente línea va a retornar el valor de cero, que significa que todo ha funcionado correctamente

113
00:07:19,540 --> 00:07:20,380
en nuestro programa.

114
00:07:20,590 --> 00:07:22,660
Vamos a presionar de nueva cuenta este hover.

115
00:07:23,410 --> 00:07:25,300
Ya estamos en la última línea de código.

116
00:07:26,450 --> 00:07:31,310
Y entonces con eso termina de ejecutarse nuestro programa y entonces en nuestra animación lo que sucedería

117
00:07:31,610 --> 00:07:36,500
es que termina de ejecutarse nuestro programa principal, nuestra función main y por lo tanto también

118
00:07:36,500 --> 00:07:38,810
se destruye de memoria nuestra variable.

119
00:07:39,020 --> 00:07:44,360
Así que la siguiente vez que volviéramos a ejecutar nuestro programa, volvemos a iniciar desde la línea

120
00:07:44,360 --> 00:07:48,530
cinco y entonces esta variable se declara en otra posición de memoria.

121
00:07:48,710 --> 00:07:50,300
Se vuelve a crear nuestra variable.

122
00:07:50,660 --> 00:07:53,660
La variable de mi número, pero con otra posición de memoria.

123
00:07:53,840 --> 00:07:54,470
Por lo tanto.

124
00:07:54,470 --> 00:07:55,400
El valor inicial.

125
00:07:55,400 --> 00:08:00,320
Recordemos que si no le hemos asignado otro valor, su valor inicial va a ser un valor basura, ya que

126
00:08:00,320 --> 00:08:05,780
se encuentra almacenando este valor basura si es que no le hemos asignado un valor inicial y con eso

127
00:08:05,780 --> 00:08:07,640
ya terminamos de ejecutar nuestro modo debug.

128
00:08:07,940 --> 00:08:12,770
Y por último, podemos quitar este punto de ruptura y con esto ya hemos terminado de ejecutar paso a

129
00:08:12,770 --> 00:08:13,790
paso a nuestro programa.

130
00:08:14,180 --> 00:08:18,500
Si queremos volver a ejecutar el modo paso a paso, simplemente presionamos este ícono.

131
00:08:19,880 --> 00:08:22,520
Para poder ejecutar nuestro programa de una sola vez.

132
00:08:22,640 --> 00:08:25,250
Pero ya sabemos que se ejecuta línea a línea.

133
00:08:25,490 --> 00:08:31,850
Así que desde la línea cinco hasta la línea 15 se va ejecutando una a una cada una de estas líneas.

134
00:08:32,810 --> 00:08:37,580
Así que esta es la forma en que se ejecutan los programas de manera secuencial, desde la primera línea

135
00:08:37,580 --> 00:08:38,780
hasta la última línea.

136
00:08:39,170 --> 00:08:42,740
Además, también hemos visto cómo ejecutar paso a paso nuestro programa.

137
00:08:42,920 --> 00:08:48,020
Esto nos va a servir bastante para poder encontrar errores en caso de que los encontremos al momento

138
00:08:48,020 --> 00:08:49,460
de ejecutar nuestros programas.

139
00:08:49,730 --> 00:08:55,130
Así que este modo debug o modo depuración nos va a permitir encontrar ese tipo de errores y poderlos

140
00:08:55,130 --> 00:08:56,570
resolver más fácilmente.

141
00:08:56,830 --> 00:09:01,900
Bien, pongo en práctica este ejemplo, incluyendo este modo de y nos vemos en el siguiente vídeo.

142
00:09:02,000 --> 00:09:02,570
Saludos.
