1
00:00:01,070 --> 00:00:26,800
Vale, pues venga. Ahora sí, ¿vale? Entonces. Vale, pues venga. Pequeña introducción a la programación, que es nuestra tarea. Bueno, ¿por qué tenemos que programar? Hombre, pues no tenemos que hacerlo. Podríamos resolver los problemas de otra manera.

2
00:00:26,800 --> 00:00:29,420
pero es que resulta que alguien

3
00:00:29,420 --> 00:00:31,600
decidió hace un montón

4
00:00:31,600 --> 00:00:33,079
de años, un montón de años

5
00:00:33,079 --> 00:00:34,939
mucho antes de que yo naciera incluso

6
00:00:34,939 --> 00:00:36,579
o mucho, mucho, mucho

7
00:00:36,579 --> 00:00:39,280
descubrió en los tiempos de antes

8
00:00:39,280 --> 00:00:41,240
no en los de ahora, que son mucho mejores

9
00:00:41,240 --> 00:00:42,179
faltaría más

10
00:00:42,179 --> 00:00:44,399
pues de repente un tío

11
00:00:44,399 --> 00:00:47,520
que al pobre le trataron muy mal además

12
00:00:47,520 --> 00:00:49,880
¿qué?

13
00:00:51,380 --> 00:00:53,259
claro que lo habéis dado, en sistemas

14
00:00:53,259 --> 00:00:55,259
pues un tío muy listo

15
00:00:55,259 --> 00:00:56,520
dijo

16
00:00:56,520 --> 00:00:59,700
jolines, tenemos una arquitectura

17
00:00:59,700 --> 00:01:03,000
que nos permite resolver de forma automática

18
00:01:03,000 --> 00:01:05,079
algunos problemas, no todos

19
00:01:05,079 --> 00:01:08,640
pero algunos sí, y esa arquitectura

20
00:01:08,640 --> 00:01:10,140
de Von Neumann, los que habéis

21
00:01:10,140 --> 00:01:13,620
estudiado el ciclo de sistemas

22
00:01:13,620 --> 00:01:17,500
pues os la conocéis de memoria, nosotros vamos a simplificar

23
00:01:17,500 --> 00:01:20,000
muy por encima, no vamos a detenernos en ello

24
00:01:20,000 --> 00:01:22,379
¿pero en qué consiste?

25
00:01:24,459 --> 00:01:26,640
pues tenemos una cosa que se llama CPU

26
00:01:26,640 --> 00:01:30,659
que tiene unos registros

27
00:01:30,659 --> 00:01:32,540
dentro, unos cuantos registros

28
00:01:32,540 --> 00:01:33,459
para meter datos

29
00:01:33,459 --> 00:01:36,439
y además tiene una cosa estupenda

30
00:01:36,439 --> 00:01:38,260
que es una unidad

31
00:01:38,260 --> 00:01:39,579
aritmético-lógica

32
00:01:39,579 --> 00:01:42,060
que ¿qué sabe hacer? sumas, restas

33
00:01:42,060 --> 00:01:44,280
chorraditas, sumas y restas

34
00:01:44,280 --> 00:01:44,920
y poquito más

35
00:01:44,920 --> 00:01:50,579
y además tiene una unidad de control

36
00:01:50,579 --> 00:01:54,739
¿para qué sirve esta unidad de control?

37
00:01:55,120 --> 00:01:56,620
para dar órdenes

38
00:01:56,640 --> 00:01:59,000
a que se muevan datos por ahí,

39
00:01:59,620 --> 00:02:01,459
porque esta unidad aritmético-lógica

40
00:02:01,459 --> 00:02:03,659
es capaz de sumar y restar

41
00:02:03,659 --> 00:02:06,099
cositas que hay en esos registros de dentro.

42
00:02:06,900 --> 00:02:08,659
Vale, pero de esos registros de dentro,

43
00:02:09,240 --> 00:02:10,439
¿de dónde le llega la información?

44
00:02:10,819 --> 00:02:12,340
Hombre, pues vamos a añadir

45
00:02:12,340 --> 00:02:14,139
la arquitectura de Von Neumann esta,

46
00:02:15,599 --> 00:02:17,580
una memoria RAM con datos.

47
00:02:18,919 --> 00:02:22,840
Entonces, ¿cómo pasan los datos de la memoria RAM

48
00:02:22,840 --> 00:02:24,400
a los registros de la CPU

49
00:02:24,400 --> 00:02:26,520
para que la unidad aritmético-lógica

50
00:02:26,520 --> 00:02:28,500
sea capaz de sumarlos

51
00:02:28,500 --> 00:02:30,020
restarlos o lo que haga falta

52
00:02:30,020 --> 00:02:31,719
vamos a poner unos cablecitos

53
00:02:31,719 --> 00:02:34,460
pues venga, ponemos unos cablecitos por ahí

54
00:02:34,460 --> 00:02:36,060
que son los buses

55
00:02:36,060 --> 00:02:38,199
un montón de cablecitos

56
00:02:38,199 --> 00:02:40,620
estos buses pues tienen acceso

57
00:02:40,620 --> 00:02:42,000
desde ellos la RAM

58
00:02:42,000 --> 00:02:43,620
tiene acceso la CPU

59
00:02:43,620 --> 00:02:46,460
y no solo eso, también tiene acceso

60
00:02:46,460 --> 00:02:48,379
unas unidades

61
00:02:48,379 --> 00:02:49,539
de entrada y salida

62
00:02:49,539 --> 00:02:52,520
que hay por ahí que a mí me nos importan menos

63
00:02:52,520 --> 00:02:54,560
por si alguien desde

64
00:02:54,560 --> 00:02:56,620
fuera, el que no está físicamente

65
00:02:56,620 --> 00:02:59,000
metido ahí viviendo en la tarjeta

66
00:02:59,000 --> 00:03:00,680
en la placa, en la placa base

67
00:03:00,680 --> 00:03:02,639
para el que no está metido en la placa base

68
00:03:02,639 --> 00:03:04,400
que está fuera, si quiere ver lo que pasa

69
00:03:04,400 --> 00:03:06,560
adentro, pues hombre, ese está

70
00:03:06,560 --> 00:03:08,419
aquí, no está metido dentro

71
00:03:08,419 --> 00:03:10,379
de la placa base, entonces ese

72
00:03:10,379 --> 00:03:12,560
mira aquí y ve lo que

73
00:03:12,560 --> 00:03:14,060
hay dentro, entonces esta

74
00:03:14,060 --> 00:03:16,360
unidades de entrada y salida, pues también

75
00:03:16,360 --> 00:03:18,419
se conectan a los buses para

76
00:03:18,419 --> 00:03:20,400
sacar lo que hay dentro y mostrárselo

77
00:03:20,400 --> 00:03:22,819
en una pantalla, en una impresora

78
00:03:22,819 --> 00:03:23,680
en donde sea

79
00:03:23,680 --> 00:03:26,360
vale, esto es la arquitectura

80
00:03:26,360 --> 00:03:28,340
de Von Neumann, ya está, ¿y en qué consiste

81
00:03:28,340 --> 00:03:29,800
esto? pues consiste

82
00:03:29,800 --> 00:03:32,580
en esta memoria RAM

83
00:03:32,580 --> 00:03:34,580
hay un cachito

84
00:03:34,580 --> 00:03:36,120
una porción

85
00:03:36,120 --> 00:03:37,780
que tiene una cosa

86
00:03:37,780 --> 00:03:39,360
que se llama programa

87
00:03:39,360 --> 00:03:44,590
¿y qué es una cosa que se llama programa?

88
00:03:45,349 --> 00:03:46,689
una cosa que se llama programa

89
00:03:46,689 --> 00:03:48,889
es una secuencia de instrucciones

90
00:03:48,889 --> 00:03:50,689
de órdenes, de cosas que hay que hacer

91
00:03:50,689 --> 00:03:52,129
pa pa pa pa pa

92
00:03:52,129 --> 00:03:55,110
pues aquí están, en la memoria RAM

93
00:03:55,110 --> 00:03:57,150
vale, ese programa

94
00:03:57,150 --> 00:03:58,750
para que haga algo interesante

95
00:03:58,750 --> 00:03:59,990
tiene que trabajar con datos

96
00:03:59,990 --> 00:04:02,189
suma esto, resta esto, haz esto

97
00:04:02,189 --> 00:04:04,150
¿esos datos dónde están? pues también aquí

98
00:04:04,150 --> 00:04:06,969
aquí hay otro trocito de la RAM

99
00:04:06,969 --> 00:04:08,310
que tiene datos

100
00:04:08,310 --> 00:04:12,280
vale, pues el ordenador arranca

101
00:04:12,280 --> 00:04:13,800
pum, encendemos el ordenador

102
00:04:13,800 --> 00:04:15,400
vale, pues entonces

103
00:04:15,400 --> 00:04:18,399
arranca ciertas cosas, se encienden lucecitas

104
00:04:18,399 --> 00:04:20,060
patatín patatán, se lee una memoria

105
00:04:20,060 --> 00:04:22,300
se lee una memoria que está

106
00:04:22,300 --> 00:04:24,079
ahí pequeñita, que no se borra nunca

107
00:04:24,079 --> 00:04:26,060
para hacer unas primeras inicializaciones

108
00:04:26,060 --> 00:04:28,079
etcétera, etcétera, y ahora ya empieza

109
00:04:28,079 --> 00:04:29,480
el funcionamiento general

110
00:04:29,480 --> 00:04:31,620
del equipo, ¿y cuál es?

111
00:04:32,199 --> 00:04:33,959
pues que la unidad

112
00:04:33,959 --> 00:04:35,959
de control va dando órdenes

113
00:04:35,959 --> 00:04:37,399
una tras otra, pa, pa, pa

114
00:04:37,399 --> 00:04:39,680
para que a través del bus vayan pasando

115
00:04:39,680 --> 00:04:41,420
una tras otra estas instrucciones

116
00:04:41,420 --> 00:04:43,740
una aquí dentro, un registro

117
00:04:43,740 --> 00:04:45,399
interprétala

118
00:04:45,399 --> 00:04:47,939
y lo que haga

119
00:04:47,939 --> 00:04:50,120
y que la unidad aritmético

120
00:04:50,120 --> 00:04:51,899
lógica ejecute lo que te dice

121
00:04:51,899 --> 00:04:52,680
esta sentencia

122
00:04:52,680 --> 00:04:56,040
la unidad aritmético lógica lo ejecuta

123
00:04:56,040 --> 00:05:04,860
Que en última instancia solo es suma, restas y operaciones lógicas de tipo AND, OR, si os suena más o menos eso y si no, lo olvidáis.

124
00:05:05,480 --> 00:05:24,180
Vale, ya está. Siguiente sentencia. Que a lo mejor como consecuencia de esa sentencia, algunos de los datos generados que están por aquí tienen que pasar a la RAM. Vale, pues muy bien, se van a la RAM. O a lo mejor algunos tienen que pasar a encuadra y salida. Vale, la unidad de control da todas las órdenes. La unidad de control da órdenes para que pase.

125
00:05:24,180 --> 00:05:26,600
sentencia, aquí

126
00:05:26,600 --> 00:05:28,579
al registro de instrucción

127
00:05:28,579 --> 00:05:30,420
que se llama, el que tiene la sentencia

128
00:05:30,420 --> 00:05:32,279
registro de instrucción, ahora

129
00:05:32,279 --> 00:05:34,420
aquí hay una serie de circuitos

130
00:05:34,420 --> 00:05:36,740
lógicos extraños, condensadores, transistores

131
00:05:36,740 --> 00:05:39,100
cosas raras, que decodifican

132
00:05:39,100 --> 00:05:39,920
esa sentencia

133
00:05:39,920 --> 00:05:42,839
para que la unidad aritmético-lógica

134
00:05:42,839 --> 00:05:44,720
haga las sumas, restas o lo que haga falta

135
00:05:44,720 --> 00:05:46,680
como consecuencia de esas sumas

136
00:05:46,680 --> 00:05:48,100
restas, aquí aparecen datos

137
00:05:48,100 --> 00:05:50,079
en los registros de la CPU

138
00:05:50,079 --> 00:05:52,420
y esos datos, wow

139
00:05:52,420 --> 00:05:53,560
vuelven hacia la rama

140
00:05:53,560 --> 00:05:56,300
a través de los bus, vuelven aquí

141
00:05:56,300 --> 00:05:58,480
a la siguiente, siguiente sentencia

142
00:05:58,480 --> 00:06:00,660
muy bien, siguiente sentencia, el registro de instrucción

143
00:06:00,660 --> 00:06:02,699
los circuitillos que hay por aquí

144
00:06:02,699 --> 00:06:04,259
la decodifican

145
00:06:04,259 --> 00:06:06,300
como consecuencia de decodificar

146
00:06:06,300 --> 00:06:08,600
de decodificarla, esta hace su suma

147
00:06:08,600 --> 00:06:10,560
y sus restas, los resultados

148
00:06:10,560 --> 00:06:12,060
vuelven aquí

149
00:06:12,060 --> 00:06:14,879
y así todo el rato, así todo el rato

150
00:06:14,879 --> 00:06:16,220
y eso es lo que hace un ordenador

151
00:06:16,220 --> 00:06:17,779
todo el rato, ya está

152
00:06:17,779 --> 00:06:19,959
el propio sistema operativo que es

153
00:06:19,959 --> 00:06:21,819
un programa que está aquí cargado

154
00:06:21,819 --> 00:06:23,819
el sistema operativo inicialmente

155
00:06:23,819 --> 00:06:26,439
está en el disco duro

156
00:06:26,439 --> 00:06:28,040
por supuesto, ahí está el sistema operativo

157
00:06:28,040 --> 00:06:30,720
pero cuando el ordenador

158
00:06:30,720 --> 00:06:32,740
se arranca, en el disco duro

159
00:06:32,740 --> 00:06:33,980
no pinta nada eso ahí

160
00:06:33,980 --> 00:06:36,000
¿qué es lo que se hace automáticamente?

161
00:06:36,439 --> 00:06:38,959
todo el programa o parte del sistema operativo

162
00:06:38,959 --> 00:06:40,680
pam, a la RAM

163
00:06:40,680 --> 00:06:41,639
ahí se queda

164
00:06:41,639 --> 00:06:43,480
y a partir de ahí ya empieza

165
00:06:43,480 --> 00:06:46,180
primera secuencia del sistema operativo

166
00:06:46,180 --> 00:06:48,279
aquí, la decodifico y la hago

167
00:06:48,279 --> 00:06:49,500
segunda, tercera

168
00:06:49,500 --> 00:06:51,319
que ahora el sistema operativo

169
00:06:51,319 --> 00:06:53,000
llama a otro programa

170
00:06:53,000 --> 00:06:54,240
porque yo he dado a un clic

171
00:06:54,240 --> 00:06:56,040
pues entonces

172
00:06:56,040 --> 00:06:59,180
la instrucción de ese programa es la que pasa

173
00:06:59,180 --> 00:07:00,319
aquí y así todo el rato

174
00:07:00,319 --> 00:07:01,980
y eso todo el rato es lo que está haciendo

175
00:07:01,980 --> 00:07:03,100
todo el rato

176
00:07:03,100 --> 00:07:07,079
pues esta es muy en resumen

177
00:07:07,079 --> 00:07:08,879
la arquitectura de Von Neumann

178
00:07:08,879 --> 00:07:10,220
y esto es

179
00:07:10,220 --> 00:07:13,079
lo que tenéis en una placa base

180
00:07:13,079 --> 00:07:14,420
cuando la abrís, ya está

181
00:07:14,420 --> 00:07:17,819
todo esto, pues la tarjeta gráfica

182
00:07:17,819 --> 00:07:19,459
los buses, la RAM

183
00:07:19,459 --> 00:07:20,959
el microprocesador

184
00:07:20,959 --> 00:07:23,480
pues en resumen eso es lo que tenéis en una placa base

185
00:07:23,480 --> 00:07:24,439
cuando lo hacéis todo eso

186
00:07:24,439 --> 00:07:27,980
bueno entonces como veis

187
00:07:27,980 --> 00:07:29,680
los programas

188
00:07:29,680 --> 00:07:31,860
son una cosa muy fea

189
00:07:31,860 --> 00:07:33,899
y muy difícil de entender y muy complicada

190
00:07:33,899 --> 00:07:35,660
de hacer porque que hay

191
00:07:35,660 --> 00:07:36,680
en una memoria RAM

192
00:07:36,680 --> 00:07:38,279
ceros y unos

193
00:07:38,279 --> 00:07:40,560
eso es lo único que hay

194
00:07:40,560 --> 00:07:43,779
ceros y unos porque eso es lo único

195
00:07:43,779 --> 00:07:45,800
que un ordenador puede almacenar

196
00:07:45,800 --> 00:07:47,800
dentro y lo único

197
00:07:47,800 --> 00:07:49,800
que una unidad aritmético lógica

198
00:07:49,800 --> 00:07:51,220
o una CPU puede entender.

199
00:07:51,579 --> 00:07:51,939
Lo único.

200
00:07:53,860 --> 00:07:56,199
Luego un programa son un montón de

201
00:07:56,199 --> 00:07:57,879
ceros y unos

202
00:07:57,879 --> 00:07:59,660
que significan cosas.

203
00:08:00,540 --> 00:08:01,879
¿Y qué significan?

204
00:08:02,199 --> 00:08:03,579
Hostia, bueno, tendría que aprender.

205
00:08:04,500 --> 00:08:05,540
Estos ceros y unos

206
00:08:05,540 --> 00:08:07,500
significan esto, estos ceros y unos significan esto.

207
00:08:08,319 --> 00:08:09,779
Claro, ¿alguien puede hacer eso?

208
00:08:10,100 --> 00:08:11,500
Es absolutamente imposible.

209
00:08:11,920 --> 00:08:13,500
Con lo cual no se programa

210
00:08:13,500 --> 00:08:15,740
directamente poniendo ceros y unos.

211
00:08:16,339 --> 00:08:16,500
¿Vale?

212
00:08:17,339 --> 00:08:18,720
Este es el lenguaje máquina.

213
00:08:19,800 --> 00:08:31,000
El programa en ceros y unos, el que está directamente en la RAM ahí metido, el real, el único que vale, el que está en la RAM, este programa es lo que se llama lenguaje máquina, ¿vale?

214
00:08:37,889 --> 00:08:48,990
Un programa en lenguaje máquina es un programa que ya está en la RAM, ¿vale? Y está en bits, en ceros y unos, ¿vale?

215
00:08:48,990 --> 00:08:53,370
¿Vale? Esa nomenclatura, aunque solo sea de bachillerato la ESO, sonará, ¿no?

216
00:08:53,370 --> 00:08:58,669
Cada uno de esos es un bit, que normalmente están agrupados como mínimo de 8 en 8, que es un byte.

217
00:08:59,309 --> 00:09:03,809
Bueno, pues un programa directamente escrito ya en bits, en 0s y 1s, y cargado en RAM,

218
00:09:03,889 --> 00:09:06,370
que es lo único que puede tener la RAM, es un programa en lenguaje máquina.

219
00:09:07,389 --> 00:09:13,090
¿Qué ocurre? Que así no podemos darle órdenes a la CPU, es imposible, nadie puede programar en 0s y 1s.

220
00:09:14,090 --> 00:09:17,789
Vale, pues entonces, se hizo un primer salto.

221
00:09:18,029 --> 00:09:20,309
Hablo del origen de esos tiempos de antes.

222
00:09:21,429 --> 00:09:25,230
Digo, como los ceros no son muy complicados, vamos a hacer un primer salto,

223
00:09:26,149 --> 00:09:28,870
que es el lenguaje ensamblador.

224
00:09:37,149 --> 00:09:41,210
Vale, pues el lenguaje ensamblador es un lenguaje de programación,

225
00:09:41,210 --> 00:09:45,009
ya es algo que uno puede escribir con letras y números, con algo que le suena,

226
00:09:45,610 --> 00:09:46,750
porque los ceros y números no suenan.

227
00:09:46,750 --> 00:09:49,970
el lenguaje ensamblador ya es algo que uno escribe con letras

228
00:09:49,970 --> 00:09:51,009
con cosas que suenan

229
00:09:51,009 --> 00:09:53,909
y escribe ahí sus órdenes el lenguaje ensamblador

230
00:09:53,909 --> 00:09:55,529
pero es muy raro

231
00:09:55,529 --> 00:09:58,090
porque son órdenes muy muy muy básicas

232
00:09:58,090 --> 00:09:59,690
el lenguaje ensamblador

233
00:09:59,690 --> 00:10:02,029
es el lenguaje que le da

234
00:10:02,029 --> 00:10:03,789
todo completamente

235
00:10:03,789 --> 00:10:05,809
triturado, desglosado

236
00:10:05,809 --> 00:10:07,870
y machacado a la unidad aritmético-lógica

237
00:10:07,870 --> 00:10:09,450
suma esto con esto

238
00:10:09,450 --> 00:10:11,070
mueve esto a este registro

239
00:10:11,070 --> 00:10:14,350
ahora suma esto con esto, mueve esto a este otro registro

240
00:10:14,350 --> 00:10:15,429
madre mía

241
00:10:15,429 --> 00:10:17,929
hacer cualquier cosa en lenguaje ensamblador

242
00:10:17,929 --> 00:10:19,529
directamente, son

243
00:10:19,529 --> 00:10:20,870
tropecientes líneas de lenguaje

244
00:10:20,870 --> 00:10:23,750
lo que pasa es que una vez que está

245
00:10:23,750 --> 00:10:25,809
en lenguaje ensamblador, traducirlo

246
00:10:25,809 --> 00:10:26,750
al lenguaje máquina

247
00:10:26,750 --> 00:10:28,529
es muy fácil

248
00:10:28,529 --> 00:10:32,230
hay un pequeño software, ya directamente

249
00:10:32,230 --> 00:10:33,990
te lleva, te lo traduce

250
00:10:33,990 --> 00:10:35,950
a ceros y unos, muy rápido

251
00:10:35,950 --> 00:10:37,870
e inmediato, porque casi

252
00:10:37,870 --> 00:10:39,750
cada sentencia de lenguaje ensamblador

253
00:10:39,750 --> 00:10:41,230
casi cada una de ellas es un byte

254
00:10:41,230 --> 00:10:43,710
es un lenguaje tan básico, que te lo da todo

255
00:10:43,710 --> 00:10:45,090
tan, tan, tan, tan machacado

256
00:10:45,090 --> 00:10:51,909
Y el lenguaje ensamblador se ha programado muchísimo, para que veáis la pinta que tiene el lenguaje ensamblador.

257
00:10:52,009 --> 00:11:12,879
Por ejemplo, si vamos a ver un explorador y poner cualquier ejemplo de código ensamblador, vale,

258
00:11:17,019 --> 00:11:36,360
ah no, que esto es un vídeo, yo quiero una imagen, imágenes, vale, pues, es que ni siquiera se,

259
00:11:36,360 --> 00:11:39,139
bueno, no he cogido una imagen que se vea muy bien

260
00:11:39,139 --> 00:11:41,600
bueno, y aparte es bastante complicado

261
00:11:41,600 --> 00:11:41,899
verlo

262
00:11:41,899 --> 00:12:03,919
vale, pues el lenguaje ensamblador ya es algo que uno puede

263
00:12:03,919 --> 00:12:05,840
escribir en realidad, lo escribe en su blog

264
00:12:05,840 --> 00:12:06,899
de notas donde haga falta

265
00:12:06,899 --> 00:12:09,740
y es algo que tiene un aspecto

266
00:12:09,740 --> 00:12:10,980
como esto

267
00:12:10,980 --> 00:12:12,639
a ver si sale bien

268
00:12:12,639 --> 00:12:22,779
vale, como veis

269
00:12:22,779 --> 00:12:24,220
son

270
00:12:24,220 --> 00:12:26,759
términos muy extraños

271
00:12:26,759 --> 00:12:28,740
letras muy raras

272
00:12:28,740 --> 00:12:30,460
veis, aquí veis atcu

273
00:12:30,460 --> 00:12:32,240
esto significa suma

274
00:12:32,240 --> 00:12:34,860
suma lo que hay en este registro

275
00:12:34,860 --> 00:12:36,000
a este otro registro

276
00:12:36,000 --> 00:12:38,600
son sentencias muy básicas

277
00:12:38,600 --> 00:12:40,259
cualquier algoritmo

278
00:12:40,259 --> 00:12:41,740
con ponerlo en ensamblador

279
00:12:41,740 --> 00:12:43,039
son un montón de sentencias

280
00:12:43,039 --> 00:12:44,559
pero tienes que dar muy desglosado

281
00:12:44,559 --> 00:12:48,000
entonces, estos son comentarios

282
00:12:48,000 --> 00:12:49,539
veis aquí

283
00:12:49,539 --> 00:12:51,820
con esto está haciendo un error exclusivo

284
00:12:51,820 --> 00:12:54,120
a los que vengáis de sistemas o suene de la ESO

285
00:12:54,120 --> 00:12:56,139
de bachillerato, un error exclusivo

286
00:12:56,139 --> 00:12:57,340
de estos dos registros

287
00:12:57,340 --> 00:12:59,899
aquí una comparación

288
00:12:59,899 --> 00:13:03,139
son sentencias en realidad, ya se entienden

289
00:13:03,139 --> 00:13:04,320
add, compare

290
00:13:04,320 --> 00:13:07,080
esto ya es un lenguaje

291
00:13:07,080 --> 00:13:08,720
de programación, ya se puede programar en él

292
00:13:08,720 --> 00:13:10,059
pero sigue siendo

293
00:13:10,059 --> 00:13:11,500
un poco locura

294
00:13:11,500 --> 00:13:14,419
hacer una aplicación en ensamblador es una locura

295
00:13:14,419 --> 00:13:17,039
pero claro, ¿cuál es la ventaja?

296
00:13:17,139 --> 00:13:19,080
que si uno hace un programa en ensamblador

297
00:13:19,080 --> 00:13:21,139
tiene el control absoluto

298
00:13:21,139 --> 00:13:23,000
de todo lo que está haciendo su CPU

299
00:13:23,000 --> 00:13:24,759
de todo, porque es que

300
00:13:24,759 --> 00:13:26,879
le está dando paso a paso lo que tiene que hacer

301
00:13:26,879 --> 00:13:28,440
no tiene ningún margen

302
00:13:28,440 --> 00:13:29,299
de maniobra

303
00:13:29,299 --> 00:13:35,960
vale, pero

304
00:13:35,960 --> 00:13:38,360
por ejemplo, en aplicaciones

305
00:13:38,360 --> 00:13:40,580
en aplicaciones en las cuales

306
00:13:40,580 --> 00:13:42,000
uno tiene

307
00:13:42,000 --> 00:13:44,379
un sistema de control controlado por una

308
00:13:44,379 --> 00:13:46,299
CPU y es fundamental

309
00:13:46,299 --> 00:13:50,399
pues que funcione, está controlando

310
00:13:50,399 --> 00:13:52,360
una cinta de embalaje

311
00:13:52,360 --> 00:13:54,379
yo que sé, una cinta industrial, cualquier cosa

312
00:13:54,379 --> 00:13:56,620
y ahí es crítico que el funcionamiento

313
00:13:56,620 --> 00:13:58,419
no falle, los tiempos

314
00:13:58,419 --> 00:13:59,960
todo, pues esa CPU

315
00:13:59,960 --> 00:14:02,320
que controla a lo mejor esa línea de montaje

316
00:14:02,320 --> 00:14:04,519
pues ahí lo ideal directamente

317
00:14:04,519 --> 00:14:06,220
es programarla en su lenguaje ensamblador

318
00:14:06,220 --> 00:14:08,700
entonces controlas exactamente lo que está en esa CPU

319
00:14:08,700 --> 00:14:10,480
pero claro, una aplicación

320
00:14:10,480 --> 00:14:12,220
de mi tienda de

321
00:14:12,220 --> 00:14:14,139
de ositos de peluche

322
00:14:14,139 --> 00:14:15,460
pues no la voy a programar en ensamblador

323
00:14:15,460 --> 00:14:18,379
o mi tienda de ositos de peluche, pues tampoco es tan crítico

324
00:14:18,379 --> 00:14:20,639
que la CPU sume los peluches como dé la gana

325
00:14:20,639 --> 00:14:22,039
da igual, ¿vale?

326
00:14:22,100 --> 00:14:24,820
entonces, no programamos en ensamblador

327
00:14:24,820 --> 00:14:26,720
siguiente salto

328
00:14:26,720 --> 00:14:38,059
Siguiente salto

329
00:14:38,059 --> 00:14:40,679
Como

330
00:14:40,679 --> 00:14:44,379
Vale, entonces como somos muy vagos

331
00:14:44,379 --> 00:14:45,580
Para programar en el ensamblador

332
00:14:45,580 --> 00:14:48,620
Aparte, no solo el problema de la baguería

333
00:14:48,620 --> 00:14:49,399
Ya natural

334
00:14:49,399 --> 00:14:52,100
Sino que programar en el ensamblador implica

335
00:14:52,100 --> 00:14:54,600
Que tú tienes que programar para una CPU en concreto

336
00:14:54,600 --> 00:14:56,059
Hombre, eso no nos gusta

337
00:14:56,059 --> 00:14:57,899
Nos gustan programas que me valgan

338
00:14:57,899 --> 00:14:59,120
Para cualquier ordenador

339
00:14:59,120 --> 00:15:01,039
Bueno, pues por esos problemas

340
00:15:01,039 --> 00:15:03,779
Por lo prácticamente imposible

341
00:15:03,779 --> 00:15:05,759
Que es programar en el ensamblador

342
00:15:05,759 --> 00:15:10,539
y porque yo quiero ser multiplataforma, no solo para una CPU,

343
00:15:11,340 --> 00:15:19,100
pues se dio, o damos, el siguiente salto, que es ya el código fuente.

344
00:15:22,940 --> 00:15:26,159
Bueno, lenguajes de alto nivel, llamémosle lenguajes de alto nivel.

345
00:15:26,679 --> 00:15:38,389
Vale, pues los lenguajes de alto nivel están ya por encima del ensamblador.

346
00:15:39,289 --> 00:15:42,850
De hecho, ya que habías mencionado el C, el lenguaje C, por ejemplo,

347
00:15:43,669 --> 00:15:46,570
siempre se ha dicho que es un lenguaje intermedio,

348
00:15:46,570 --> 00:15:48,669
porque tiene mucha capacidad de tocar

349
00:15:48,669 --> 00:15:49,850
a nivel de CPU

350
00:15:49,850 --> 00:15:52,549
pero no es el ensamblador, afortunadamente

351
00:15:52,549 --> 00:15:54,090
y también tiene

352
00:15:54,090 --> 00:15:56,750
las estructuras y las ventajas de los lenguajes

353
00:15:56,750 --> 00:15:58,750
de alto nivel, entonces el C

354
00:15:58,750 --> 00:16:00,629
es un lenguaje, siempre se ha dicho

355
00:16:00,629 --> 00:16:02,730
que intermedio, por eso es un lenguaje que se ha usado mucho

356
00:16:02,730 --> 00:16:04,929
para programar sistemas operativos

357
00:16:04,929 --> 00:16:06,490
por ejemplo, como Linux, etc

358
00:16:06,490 --> 00:16:08,110
vale, pero

359
00:16:08,110 --> 00:16:10,450
normalmente programamos en lenguajes de

360
00:16:10,450 --> 00:16:12,230
más alto nivel, entre comillas

361
00:16:12,230 --> 00:16:14,509
el alto nivel no es porque sean mejores, de hecho

362
00:16:14,509 --> 00:16:16,490
no, siempre sería mejor esto

363
00:16:16,490 --> 00:16:25,649
El alto nivel es porque me abstraen de un montón de problemas que hay debajo y yo programo como si fuera tonto.

364
00:16:26,129 --> 00:16:35,210
Le doy unas instrucciones muy genéricas, lee del teclado y yo pongo lee del teclado directamente en mi sentencia

365
00:16:35,210 --> 00:16:44,009
y ya cuando se traduce eso a código máquina, una única sentencia de alto nivel, lee del teclado,

366
00:16:44,009 --> 00:16:45,789
pues a lo mejor se traduce en mil

367
00:16:45,789 --> 00:16:48,049
de código máquina. Y yo esa traducción

368
00:16:48,049 --> 00:16:50,090
no la hago. Ya veremos cómo se automatiza.

369
00:16:50,169 --> 00:16:51,750
No la hago. Yo me limito a poner

370
00:16:51,750 --> 00:16:53,889
mi código de lenguaje de alto nivel.

371
00:16:54,529 --> 00:16:55,350
Lee del teclado

372
00:16:55,350 --> 00:16:57,950
y punto pelota. Y ya eso se traduce

373
00:16:57,950 --> 00:16:59,950
a mil ceros y unos.

374
00:17:00,429 --> 00:17:02,149
¿Cuál es el problema? Que la traducción

375
00:17:02,149 --> 00:17:03,769
la hacemos nosotros, perdemos el control.

376
00:17:04,269 --> 00:17:06,250
A lo mejor la traducción no es óptima.

377
00:17:07,150 --> 00:17:08,049
Y si la hago yo

378
00:17:08,049 --> 00:17:09,829
a mano, poniendo mis ceros y unos, la lectura

379
00:17:09,829 --> 00:17:12,109
del teclado es magnífica. Pero la que ha hecho

380
00:17:12,109 --> 00:17:13,869
él, pues a lo mejor hace unos

381
00:17:13,869 --> 00:17:15,769
trasbases innecesarios, entonces no

382
00:17:15,769 --> 00:17:17,890
controlamos tanto. Pero es que a veces

383
00:17:17,890 --> 00:17:19,930
es inevitable. Si no programamos con lenguaje de alto nivel

384
00:17:19,930 --> 00:17:21,049
es que no avanzamos.

385
00:17:21,630 --> 00:17:23,849
Aunque haya una parte que no controlemos, que es la

386
00:17:23,849 --> 00:17:24,769
traducción a esta.

387
00:17:25,630 --> 00:17:27,210
Bueno, pues entonces nuestro caso,

388
00:17:27,789 --> 00:17:29,990
el caso general, en el mundo comercial

389
00:17:29,990 --> 00:17:31,789
es el caso de usar

390
00:17:31,789 --> 00:17:32,829
lenguajes de alto nivel.

391
00:17:35,789 --> 00:17:37,910
Y lenguajes de alto nivel, pues ya os suenan

392
00:17:37,910 --> 00:17:40,150
todos. Lenguajes de alto nivel

393
00:17:40,150 --> 00:17:41,990
os suena todo, pues os suena Python,

394
00:17:42,170 --> 00:17:43,970
claro, os suena Java,

395
00:17:44,450 --> 00:17:48,210
Os suena a cesar, que son de los tres más usados

396
00:17:48,210 --> 00:17:49,609
Y hay tropecientos mil más

397
00:17:49,609 --> 00:17:51,170
Lenguajes de alto nivel

398
00:17:51,170 --> 00:17:53,569
Y todos son lo mismo

399
00:17:53,569 --> 00:17:54,630
Esencialmente

400
00:17:54,630 --> 00:17:58,849
C++, que aunque está más antiguo que cesar

401
00:17:58,849 --> 00:18:00,170
Todos son lo mismo

402
00:18:00,170 --> 00:18:03,789
Un montón de sentencias

403
00:18:03,789 --> 00:18:06,630
Que uno escribe en un fichero de texto

404
00:18:06,630 --> 00:18:09,329
Y esas sentencias

405
00:18:09,329 --> 00:18:11,069
De alguna manera mágica

406
00:18:11,069 --> 00:18:12,190
O no mágica

407
00:18:12,190 --> 00:18:15,430
Alguien las traduce a esto

408
00:18:15,430 --> 00:18:18,809
los cero signos, que esto es lo válido, ¿vale?

409
00:18:19,730 --> 00:18:22,269
Bueno, pues entonces, los lenguajes de alto nivel, repito,

410
00:18:22,390 --> 00:18:32,099
se basan en la escritura de un código fuente, ¿vale?

411
00:18:32,180 --> 00:18:33,559
¿Qué es mi código fuente?

412
00:18:34,420 --> 00:18:37,759
Un montón de sentencias, una tras otra,

413
00:18:39,339 --> 00:18:47,130
escritas en el lenguaje correspondiente, ¿vale?

414
00:18:47,329 --> 00:19:00,660
A ver, ¿vale? ¿El código fuente qué es?

415
00:19:00,660 --> 00:19:02,880
Es un fichero de texto,

416
00:19:02,880 --> 00:19:05,440
fichero de texto

417
00:19:05,440 --> 00:19:09,460
es decir, un fichero que tiene

418
00:19:09,460 --> 00:19:11,799
código ASCII, texto, letritas

419
00:19:11,799 --> 00:19:13,680
que uno pone en el blog de notas, donde sea

420
00:19:13,680 --> 00:19:15,920
no en el Word, porque el Word no es un editor

421
00:19:15,920 --> 00:19:17,599
de texto, el Word es otra cosa

422
00:19:17,599 --> 00:19:19,339
que escribe sus caracteres extraños

423
00:19:19,339 --> 00:19:21,900
el código fuente es un fichero

424
00:19:21,900 --> 00:19:23,380
que tiene exclusivamente

425
00:19:23,380 --> 00:19:25,799
caracteres ASCII, texto, nada más

426
00:19:25,799 --> 00:19:27,940
no tiene caracteres de control del Word

427
00:19:27,940 --> 00:19:29,279
no tiene formato, no tiene nada

428
00:19:29,279 --> 00:19:31,880
bueno, pues el código fuente es un fichero

429
00:19:31,880 --> 00:19:33,500
de texto exclusivamente

430
00:19:33,500 --> 00:19:35,299
caracteres ASCII

431
00:19:35,299 --> 00:19:37,039
que contiene

432
00:19:37,039 --> 00:19:41,900
una secuencia de sentencias

433
00:19:41,900 --> 00:19:52,980
escrita en el lenguaje correspondiente

434
00:19:52,980 --> 00:19:54,839
según las reglas del lenguaje, claro

435
00:19:54,839 --> 00:20:03,720
¿vale? según las reglas

436
00:20:03,720 --> 00:20:05,539
de un lenguaje de

437
00:20:05,539 --> 00:20:10,079
programación, ese es el

438
00:20:10,079 --> 00:20:11,759
código, el fichero de texto que contiene

439
00:20:11,759 --> 00:20:13,480
la secuencia de sentencias escrita

440
00:20:13,480 --> 00:20:15,500
según las reglas que me diga

441
00:20:15,500 --> 00:20:17,180
el lenguaje de programación, ¿vale?

442
00:20:17,980 --> 00:20:19,720
claro, el problema es cómo construyo

443
00:20:19,720 --> 00:20:23,140
su fichero, pero bueno, ya estamos con

444
00:20:23,140 --> 00:20:24,740
el contexto de la operación.

445
00:20:26,160 --> 00:20:28,579
Vale, este código fuente, este fichero,

446
00:20:29,339 --> 00:20:30,480
¿a lo largo le vale para algo?

447
00:20:31,299 --> 00:20:32,960
Para nada, esto no vale para nada.

448
00:20:33,579 --> 00:20:35,920
Esto es un fichero de texto que tiene carácter exástico.

449
00:20:36,559 --> 00:20:37,880
¿La CPU qué va a hacer con eso?

450
00:20:38,240 --> 00:20:39,519
¿Qué es la que ejecuta las cosas?

451
00:20:39,579 --> 00:20:40,579
La CPU no va a hacer nada.

452
00:20:41,240 --> 00:20:43,740
Recordad que la CPU lo que necesita

453
00:20:43,740 --> 00:20:47,400
es en una RAM un montón de ceros y unos

454
00:20:47,400 --> 00:20:51,079
para luego ya interpretarlas

455
00:20:51,079 --> 00:20:51,420
aquí

456
00:20:51,420 --> 00:20:53,759
¿vale?

457
00:20:57,140 --> 00:20:58,980
entonces, el fichero de texto no vale

458
00:20:58,980 --> 00:21:00,900
para nada, yo lo tengo ahí en mi escritorio

459
00:21:00,900 --> 00:21:01,819
donde se, no vale para nada

460
00:21:01,819 --> 00:21:04,740
entonces, para que esto se ejecute

461
00:21:04,740 --> 00:21:06,259
la CPU sea capaz de ejecutarlo

462
00:21:06,259 --> 00:21:08,400
tenemos que transformarlo

463
00:21:08,400 --> 00:21:11,980
a código máquina

464
00:21:11,980 --> 00:21:14,440
¿vale? entonces, código

465
00:21:14,440 --> 00:21:16,519
fuente, el fichero de texto con la

466
00:21:16,519 --> 00:21:18,839
secuencia de caracteres

467
00:21:18,839 --> 00:21:21,759
según el lenguaje de programación

468
00:21:21,759 --> 00:21:25,579
código máquina

469
00:21:25,579 --> 00:21:28,140
los ceros y unos que van a la RAM

470
00:21:28,140 --> 00:21:30,299
que son el resultado de traducir

471
00:21:30,299 --> 00:21:32,079
esto de aquí y que ya se ejecutan en la RAM

472
00:21:32,079 --> 00:21:34,720
aquí estaría el código máquina

473
00:21:34,720 --> 00:21:42,259
bueno, pues

474
00:21:42,259 --> 00:21:44,059
¿cómo se hace esta traducción?

475
00:21:45,599 --> 00:21:45,940
hay

476
00:21:45,940 --> 00:21:48,339
varios modelos distintos de hacerlo

477
00:21:48,339 --> 00:21:50,700
pero son tres en general

478
00:21:50,700 --> 00:21:51,559
tres en general

479
00:21:51,559 --> 00:21:54,480
vamos a ver, traducción de código fuente a código máquina

480
00:21:54,480 --> 00:21:57,380
problema fundamental, claro

481
00:21:57,380 --> 00:22:06,660
vale, tenemos

482
00:22:06,660 --> 00:22:08,539
nuestro código fuente

483
00:22:08,539 --> 00:22:16,480
y tenemos que pasarlo a código

484
00:22:16,480 --> 00:22:22,730
máquina, cuando ya lo hayamos

485
00:22:22,730 --> 00:22:24,730
pasado a código máquina ya podremos hacer el click

486
00:22:24,730 --> 00:22:26,829
para ejecutarlo, claro que ya se podrá

487
00:22:26,829 --> 00:22:28,410
cargar en la rama, etcétera

488
00:22:28,410 --> 00:22:30,569
vale, ¿cómo? ¿cómo se puede hacer esto?

489
00:22:31,470 --> 00:22:32,369
bueno, pues hay tres

490
00:22:32,369 --> 00:22:34,230
filosofías, digamos distintas

491
00:22:34,230 --> 00:22:36,470
una es

492
00:22:36,470 --> 00:22:37,730
la compilación

493
00:22:37,730 --> 00:22:44,569
Otra es la interpretación

494
00:22:44,569 --> 00:22:52,990
Y otra es la intermedia

495
00:22:52,990 --> 00:22:54,650
Ni una ni otra, un poquito de las dos

496
00:22:54,650 --> 00:23:04,380
¿Vale?

497
00:23:05,160 --> 00:23:06,819
Serían las tres filosofías

498
00:23:06,819 --> 00:23:09,700
De pasar de un código fuente

499
00:23:09,700 --> 00:23:12,380
A la ejecución ya de un código mágico

500
00:23:12,380 --> 00:23:14,940
La tradicional

501
00:23:14,940 --> 00:23:17,720
Ha venido siendo siempre

502
00:23:17,720 --> 00:23:19,440
La compilación

503
00:23:19,440 --> 00:23:25,009
¿En qué consiste el proceso de compilación?

504
00:23:25,890 --> 00:23:26,230
Bueno

505
00:23:26,230 --> 00:23:29,029
Consiste simplemente en que existe

506
00:23:29,029 --> 00:23:30,730
un software que se llama

507
00:23:30,730 --> 00:23:31,890
software compilador

508
00:23:31,890 --> 00:23:34,809
que afortunadamente no lo hace el que desarrolla

509
00:23:34,809 --> 00:23:36,789
el programa, nuestro problema es hacer el código fuente

510
00:23:36,789 --> 00:23:38,869
y ya está, bueno pues hay un

511
00:23:38,869 --> 00:23:39,970
software compilador

512
00:23:39,970 --> 00:23:45,039
que traduce y ya está

513
00:23:45,039 --> 00:23:52,470
tú a ese compilador le dices

514
00:23:52,470 --> 00:23:54,950
compila este código fuente

515
00:23:54,950 --> 00:23:56,849
prueba, no sabemos como lo hace

516
00:23:56,849 --> 00:23:59,089
y ya está, ya tiene el código máquina

517
00:23:59,089 --> 00:24:02,529
y te saca un fichero en código máquina

518
00:24:02,529 --> 00:24:04,250
tú le das un fichero en código fuente

519
00:24:04,250 --> 00:24:06,630
y te devuelve como resultado

520
00:24:06,630 --> 00:24:08,509
un fichero en código máquina

521
00:24:08,509 --> 00:24:10,349
que es lo que solemos llamar

522
00:24:10,349 --> 00:24:11,089
el ejecutable

523
00:24:11,089 --> 00:24:16,400
ese software compilador

524
00:24:16,400 --> 00:24:18,660
lo habrá desarrollado

525
00:24:18,660 --> 00:24:21,740
el que desarrolló

526
00:24:21,740 --> 00:24:22,779
el lenguaje de alguna manera

527
00:24:22,779 --> 00:24:26,380
eso es lo natural

528
00:24:26,380 --> 00:24:28,619
un poco lo que se ha hecho siempre

529
00:24:28,619 --> 00:24:31,420
pero claro, era lo natural

530
00:24:31,420 --> 00:24:32,160
sobre todo

531
00:24:32,160 --> 00:24:35,500
cuando los programas eran más pequeños

532
00:24:35,500 --> 00:24:36,859
hacían cosas más atómicas

533
00:24:36,859 --> 00:24:37,819
entonces tú tienes un programa

534
00:24:37,819 --> 00:24:39,960
lo compilabas y ya tienes el ejecutable

535
00:24:39,960 --> 00:24:41,480
y ya está

536
00:24:41,480 --> 00:24:42,579
y hacía siempre lo mismo

537
00:24:42,579 --> 00:24:45,339
entonces cuando había, cuando la tarea de programación

538
00:24:45,339 --> 00:24:46,980
estaba como más acotada

539
00:24:46,980 --> 00:24:48,660
hacías cositas pequeñas y más

540
00:24:48,660 --> 00:24:50,819
ahora ya con todo distribuido

541
00:24:50,819 --> 00:24:52,839
con aplicaciones distribuidas por internet

542
00:24:52,839 --> 00:24:54,740
con una aplicación web que para que se ejecute aquí

543
00:24:54,740 --> 00:24:55,680
para que se ejecute aquí

544
00:24:55,680 --> 00:24:58,900
ahora ya lo de compilo y tengo mi ejecutable

545
00:24:58,900 --> 00:25:00,599
y me llevo una CPU a ejecutar

546
00:25:00,599 --> 00:25:02,900
es un modelo que se ha quedado un poco rígido

547
00:25:02,900 --> 00:25:04,900
¿vale? se ha quedado un poquito rígido

548
00:25:04,900 --> 00:25:07,119
pero no deja de ser en realidad

549
00:25:07,119 --> 00:25:09,119
el mejor

550
00:25:09,119 --> 00:25:11,420
porque conduce a ejecuciones más rápidas

551
00:25:11,420 --> 00:25:14,299
tu programa ya está compilado en código máquina

552
00:25:14,299 --> 00:25:16,339
ejecutarlo, pipí, es súper rápido

553
00:25:16,339 --> 00:25:18,460
ala, la CPU va a leer

554
00:25:18,460 --> 00:25:19,680
los bits, ya está

555
00:25:19,680 --> 00:25:22,680
es lo más rápido

556
00:25:22,680 --> 00:25:23,839
a la hora de ejecutarlo

557
00:25:23,839 --> 00:25:25,799
da programas de rápida ejecución

558
00:25:25,799 --> 00:25:27,700
pero es poco flexible

559
00:25:27,700 --> 00:25:30,380
entonces

560
00:25:30,380 --> 00:25:32,960
¿en qué se basa la interpretación?

561
00:25:33,960 --> 00:25:35,039
la interpretación

562
00:25:35,039 --> 00:25:36,960
se basa en que un intérprete

563
00:25:36,960 --> 00:25:38,940
otro software

564
00:25:38,940 --> 00:25:40,599
que se llama software intérprete

565
00:25:40,599 --> 00:25:47,339
va leyendo línea por línea del código fuente

566
00:25:47,339 --> 00:26:07,779
y va ejecutando, y va traduciendo y ejecutando.

567
00:26:13,940 --> 00:26:15,359
Es el tiempo real, no tienes que estar...

568
00:26:15,359 --> 00:26:16,099
Exacto.

569
00:26:16,660 --> 00:26:18,160
No hay un ejecutable como tal.

570
00:26:18,839 --> 00:26:21,559
Tú directamente, el código fuente es el que ejecutas.

571
00:26:21,960 --> 00:26:23,619
No es que el código fuente se ejecuta,

572
00:26:23,680 --> 00:26:25,579
lo que haces es llamar al intérprete y él va,

573
00:26:26,039 --> 00:26:27,799
sentencia, la traduzco y ejecuto.

574
00:26:28,180 --> 00:26:29,839
Sentencia, la traduzco y ejecuto.

575
00:26:31,059 --> 00:26:32,799
Entonces, desventaja,

576
00:26:33,400 --> 00:26:35,539
que estas ejecuciones son mucho más lentas,

577
00:26:35,539 --> 00:26:38,299
porque cada ejecución implica una traducción

578
00:26:38,299 --> 00:26:39,660
cada vez que ejecutas

579
00:26:39,660 --> 00:26:41,200
traduzco y ejecuto

580
00:26:41,200 --> 00:26:46,039
claro, estás compilando

581
00:26:46,039 --> 00:26:47,420
una por una todo el rato

582
00:26:47,420 --> 00:26:50,160
entonces son programas

583
00:26:50,160 --> 00:26:52,220
más lentos, son lenguajes de traducción más lentos

584
00:26:52,220 --> 00:26:53,980
pero es mucho más flexible

585
00:26:53,980 --> 00:26:56,000
porque puedes parar en cualquier

586
00:26:56,000 --> 00:26:57,559
momento la ejecución

587
00:26:57,559 --> 00:27:00,240
incluso puedes

588
00:27:00,240 --> 00:27:02,059
ejecutar

589
00:27:02,059 --> 00:27:03,859
multiplataforma, pero como estás ejecutando

590
00:27:03,859 --> 00:27:06,180
por trocitos, entonces es más flexible.

591
00:27:06,700 --> 00:27:07,740
Admite más

592
00:27:07,740 --> 00:27:10,160
plataformas distintas, pero es más lento.

593
00:27:11,519 --> 00:27:11,819
Entonces,

594
00:27:12,059 --> 00:27:13,400
interpretados puros,

595
00:27:14,180 --> 00:27:15,259
pues es Python, por ejemplo.

596
00:27:15,400 --> 00:27:17,779
Python es interpretado puro, ya, así no se complica la vida.

597
00:27:18,460 --> 00:27:22,180
¿Vale? Bueno,

598
00:27:22,559 --> 00:27:24,680
entonces, ¿cuál es el intermedio? El que intenta

599
00:27:24,680 --> 00:27:26,240
no ser

600
00:27:26,240 --> 00:27:28,079
tan lento como este,

601
00:27:28,740 --> 00:27:30,539
pero no ser tan rígido

602
00:27:30,539 --> 00:27:32,359
como este, aunar las dos cosas.

603
00:27:33,180 --> 00:27:34,519
Pues la filosofía intermedia,

604
00:27:35,059 --> 00:27:36,279
que es la de Java, por ejemplo.

605
00:27:36,319 --> 00:27:51,809
vale, esta es la filosofía

606
00:27:51,809 --> 00:27:53,750
de Java, entonces partimos siempre de un código fuente

607
00:27:53,750 --> 00:27:54,390
eso está claro

608
00:27:54,390 --> 00:27:56,910
nosotros tenemos

609
00:27:56,910 --> 00:27:59,569
nuestro código fuente de Java

610
00:27:59,569 --> 00:28:05,359
que nuestro código fuente, recordad

611
00:28:05,359 --> 00:28:07,680
que es un fichero de texto, una secuencia de caracteres

612
00:28:07,680 --> 00:28:09,380
que en concreto ya podemos

613
00:28:09,380 --> 00:28:11,259
avanzar, que ese

614
00:28:11,259 --> 00:28:13,359
fichero de texto se recoge en un archivo

615
00:28:13,359 --> 00:28:15,319
pues de extensión .java

616
00:28:15,319 --> 00:28:15,759
siempre

617
00:28:15,759 --> 00:28:18,200
el nombrecito que sea

618
00:28:18,200 --> 00:28:20,500
con la extensión .java

619
00:28:20,500 --> 00:28:22,640
ese es mi fichero de texto

620
00:28:22,640 --> 00:28:24,660
escrito en el blog de notas o donde me dé la gana

621
00:28:24,660 --> 00:28:25,440
vale

622
00:28:25,440 --> 00:28:26,819
ahora

623
00:28:26,819 --> 00:28:30,779
hay una especie de pre-compilador

624
00:28:30,779 --> 00:28:32,140
pre-compilación

625
00:28:32,140 --> 00:28:39,009
pre-compilación

626
00:28:39,009 --> 00:28:40,670
que nos genera un ejecutable

627
00:28:40,670 --> 00:28:43,049
genera una versión intermedia

628
00:28:43,049 --> 00:28:45,309
pensada para que se pueda

629
00:28:45,309 --> 00:28:47,390
ejecutar en cualquier plataforma

630
00:28:47,390 --> 00:28:48,710
pensada para

631
00:28:48,710 --> 00:28:51,829
simplemente particularizando para la plataforma

632
00:28:51,829 --> 00:28:54,269
eso es una versión todavía no ejecutable

633
00:28:54,269 --> 00:28:57,009
pero que ya tiene mucha parte compilada

634
00:28:57,009 --> 00:28:59,170
y ha dejado sin compilar

635
00:28:59,170 --> 00:29:00,769
lo que depende de la

636
00:29:00,769 --> 00:29:02,309
plataforma concreta simplemente

637
00:29:02,309 --> 00:29:04,630
entonces, se hace una primera

638
00:29:04,630 --> 00:29:06,269
pre-compilación

639
00:29:06,269 --> 00:29:08,849
esta pre-compilación, ya iremos viendo

640
00:29:08,849 --> 00:29:10,750
genera unos ficheros

641
00:29:10,750 --> 00:29:12,029
con extensión .class

642
00:29:12,029 --> 00:29:14,569
es lo que genera, unos ficheros con extensión .class

643
00:29:14,569 --> 00:29:16,910
estos, repito, no son ejecutables

644
00:29:16,910 --> 00:29:18,730
todavía, pero tienen ya

645
00:29:18,730 --> 00:29:20,630
mucho código máquina metido, estos ya son

646
00:29:20,630 --> 00:29:22,509
bits, pero no son bits que

647
00:29:22,509 --> 00:29:23,289
podemos poner en la RAM.

648
00:29:25,349 --> 00:29:26,630
Entonces, ¿ahora quién entra

649
00:29:26,630 --> 00:29:28,509
en juego? Cuando ya queremos ejecutar

650
00:29:28,509 --> 00:29:30,710
este, lo que hacemos es llamar

651
00:29:30,710 --> 00:29:32,630
a la Java Virtual

652
00:29:32,630 --> 00:29:34,569
Machine, a la máquina virtual de

653
00:29:34,569 --> 00:29:46,349
Java, o la máquina virtual

654
00:29:46,349 --> 00:29:48,410
del lenguaje que sea, si estuviéramos

655
00:29:48,410 --> 00:29:50,210
con otro lenguaje que siguiera esta filosofía.

656
00:29:50,990 --> 00:29:52,250
¿Qué es esto? Esto es un software

657
00:29:52,250 --> 00:29:54,269
que, como bien sabéis, pues está

658
00:29:54,269 --> 00:29:56,289
en todos los equipos y si no, pues uno lo descarga

659
00:29:56,289 --> 00:29:58,450
y ya está. ¿Qué hace este software?

660
00:29:58,609 --> 00:30:00,250
Es un software que

661
00:30:00,250 --> 00:30:03,730
es capaz de ir interpretando una por una,

662
00:30:04,069 --> 00:30:07,329
la máquina virtual de Java va interpretando,

663
00:30:08,289 --> 00:30:12,839
interpreta el punto class

664
00:30:12,839 --> 00:30:17,220
y lo va adaptando a la plataforma en la que lo está ejecutando.

665
00:30:30,940 --> 00:30:33,420
Es decir, este punto class tiene ya mucho compilado.

666
00:30:33,539 --> 00:30:35,299
Un segundo, tiene mucho compilado.

667
00:30:35,299 --> 00:30:37,500
Pero tiene partes que todavía no.

668
00:30:38,279 --> 00:30:39,779
Entonces, la máquina virtual de Java

669
00:30:39,779 --> 00:30:42,539
va cogiendo las líneas

670
00:30:42,539 --> 00:30:44,019
que no son líneas porque esto ya no es texto

671
00:30:44,019 --> 00:30:46,559
va cogiendo los capsules del punto class

672
00:30:46,559 --> 00:30:47,299
los va cogiendo

673
00:30:47,299 --> 00:30:50,579
y los va ya convirtiendo en un ejecutable

674
00:30:50,579 --> 00:30:52,400
ahora ya sí, uno por uno

675
00:30:52,400 --> 00:30:53,799
van modo intérprete

676
00:30:53,799 --> 00:30:56,640
los va a convertir en un ejecutable pero ya adaptado

677
00:30:56,640 --> 00:30:58,339
adaptado a la máquina en la que estamos

678
00:30:58,339 --> 00:31:00,420
¿que yo este punto class

679
00:31:00,420 --> 00:31:01,480
lo llevo a ese equipo?

680
00:31:02,039 --> 00:31:04,200
genial, la máquina virtual de ese equipo

681
00:31:04,200 --> 00:31:05,259
lo interpreta sin problemas

682
00:31:05,259 --> 00:31:07,779
¿que este punto class lo llevo a una tablet?

683
00:31:07,779 --> 00:31:10,460
ningún problema, este mismo .class

684
00:31:10,460 --> 00:31:12,440
la máquina virtual de mi tablet

685
00:31:12,440 --> 00:31:14,000
lo va interpretando y adaptando

686
00:31:14,000 --> 00:31:16,619
por eso se dice que Java es multiplataforma

687
00:31:16,619 --> 00:31:18,359
porque las aplicaciones hechas

688
00:31:18,359 --> 00:31:20,319
en Java son estos

689
00:31:20,319 --> 00:31:22,660
son muchos ficheros .class

690
00:31:22,660 --> 00:31:24,259
esto es una aplicación hecha en Java

691
00:31:24,259 --> 00:31:25,420
muchos de estos

692
00:31:25,420 --> 00:31:28,140
muchos de estos es una aplicación en Java

693
00:31:28,140 --> 00:31:32,509
esto es, y la aplicación

694
00:31:32,509 --> 00:31:34,130
Java que son muchos de estos

695
00:31:34,130 --> 00:31:35,630
nada más que eso, muchos de estos

696
00:31:35,630 --> 00:31:38,250
me da igual donde la ejecute

697
00:31:38,250 --> 00:31:39,029
me da lo mismo

698
00:31:39,029 --> 00:31:41,609
porque donde yo la ejecute

699
00:31:41,609 --> 00:31:43,130
habrá una máquina virtual

700
00:31:43,130 --> 00:31:44,789
porque si no la hay no puedo ejecutarlo, claro

701
00:31:44,789 --> 00:31:47,569
habrá una máquina virtual, una Java Virtual Machine

702
00:31:47,569 --> 00:31:49,829
que cogerá ese class

703
00:31:49,829 --> 00:31:51,509
y ya lo interpretará y lo irá adaptando

704
00:31:51,509 --> 00:31:52,349
¿vale?

705
00:31:52,869 --> 00:31:55,329
claro, necesito que esta máquina virtual esté en el equipo

706
00:31:55,329 --> 00:31:56,609
donde voy a ejecutar la aplicación

707
00:31:56,609 --> 00:31:59,589
si no puede estar la máquina virtual, la aplicación Java no se puede ejecutar

708
00:31:59,589 --> 00:32:06,829
claro, pero es que tú

709
00:32:06,829 --> 00:32:09,210
Cuando tienes un equipo, tienes su máquina virtual

710
00:32:09,210 --> 00:32:11,150
dejada. Cualquier equipo que es la que

711
00:32:11,150 --> 00:32:12,349
está adaptada a ese equipo.

712
00:32:12,849 --> 00:32:15,210
Cuando te descargas, de verdad que la máquina virtual

713
00:32:15,210 --> 00:32:16,750
pues, esa máquina virtual

714
00:32:16,750 --> 00:32:18,950
tiene ya la funcionalidad

715
00:32:18,950 --> 00:32:21,130
de ir adaptando a la CPU que ella ve que hay ahí.

716
00:32:22,009 --> 00:32:22,210
¿Vale?

717
00:32:22,670 --> 00:32:22,869
¿Vale?

718
00:32:31,440 --> 00:32:31,920
¿Compilado?

719
00:32:32,740 --> 00:32:35,220
No, no, no. Está pre-compilado.

720
00:32:35,920 --> 00:32:36,400
¿Vale?

721
00:32:36,619 --> 00:32:39,019
Está, digamos, hecho como a trozos ya

722
00:32:39,019 --> 00:32:40,940
de cosas, packs, que ya están

723
00:32:40,940 --> 00:32:42,799
compiladas, pero luego hay que irlo

724
00:32:42,799 --> 00:32:45,099
montando, y eso es lo que va haciendo la máquina

725
00:32:45,099 --> 00:32:48,400
sí, como queráis llamando

726
00:32:48,400 --> 00:32:49,240
¿vale?

727
00:32:50,799 --> 00:32:52,779
o sea, tampoco os perdáis mucho en lo que hay

728
00:32:52,779 --> 00:32:54,920
dentro del punto class, pensad que hay

729
00:32:54,920 --> 00:32:56,259
una versión

730
00:32:56,259 --> 00:32:58,799
que ya no es código fuente, sino que ya algo

731
00:32:58,799 --> 00:33:00,319
hemos avanzado al código máquina

732
00:33:00,319 --> 00:33:02,980
por tanto es más rápido que esto

733
00:33:02,980 --> 00:33:04,720
porque aquel intérprete es que

734
00:33:04,720 --> 00:33:06,099
parte del código fuente directamente

735
00:33:06,099 --> 00:33:08,660
sin embargo aquí la máquina virtual

736
00:33:08,660 --> 00:33:10,519
de Java, te parte de algo

737
00:33:10,519 --> 00:33:11,900
que ya está en código máquina

738
00:33:11,900 --> 00:33:14,880
y lo único es que le falta por hacer algunas cositas

739
00:33:14,880 --> 00:33:16,900
para ya conseguir un ejecutable completo.

740
00:33:17,759 --> 00:33:18,759
Y va el poquito a poco

741
00:33:18,759 --> 00:33:19,539
cogiéndolo.

742
00:33:20,759 --> 00:33:22,220
¿Vale? Por esto Java

743
00:33:22,220 --> 00:33:24,079
no es interpretado puro

744
00:33:24,079 --> 00:33:26,240
porque tiene esta

745
00:33:26,240 --> 00:33:28,259
precompilación. Sin embargo,

746
00:33:28,400 --> 00:33:30,640
Python sí es interpretado puro. No hay una máquina virtual

747
00:33:30,640 --> 00:33:32,559
de Python. Se podría hacer una compilación después

748
00:33:32,559 --> 00:33:34,519
si ya está en una máquina. Va a ser utilizado

749
00:33:34,519 --> 00:33:35,859
en esa máquina específicamente.

750
00:33:36,279 --> 00:33:38,140
Voy a llevármelo a un RAID.

751
00:33:38,339 --> 00:33:40,019
Es una CPU específica.

752
00:33:40,019 --> 00:33:41,400
y lo tengo en .class

753
00:33:41,400 --> 00:33:43,460
¿podría hacer un compilado entero de eso ya?

754
00:33:44,319 --> 00:33:45,299
crear un ejecutable

755
00:33:45,299 --> 00:33:47,480
para llevarlo a un sitio que no tiene

756
00:33:47,480 --> 00:33:48,839
máquina virtual de Java

757
00:33:48,839 --> 00:33:51,420
no, que aunque lo tenga, pero que para dejarlo ya ejecutado

758
00:33:51,420 --> 00:33:52,640
en ese software específico

759
00:33:52,640 --> 00:33:54,920
no, o sea

760
00:33:54,920 --> 00:33:57,220
tú, la aplicación va a ser esto

761
00:33:57,220 --> 00:33:59,400
tú llevarlo a otro formato

762
00:33:59,400 --> 00:34:01,460
no lo vas a llevar nunca

763
00:34:01,460 --> 00:34:02,720
este es su formato final

764
00:34:02,720 --> 00:34:05,000
el formato final de la aplicación siempre es este

765
00:34:05,000 --> 00:34:07,559
y tú lo vas a ejecutar siempre

766
00:34:07,559 --> 00:34:08,719
con esto, sea donde sea

767
00:34:08,719 --> 00:34:24,280
Otra cosa es que tú digas, me voy a un equipo que no tiene máquina virtual de Java. Entonces, vas a tener ya que traducir y generar un ejecutable con otras herramientas de casa de juego. Pero una aplicación de Java, ya final, siempre es esto. Siempre. Un conjunto de punto clas. Por tanto, siempre necesita esto.

768
00:34:24,280 --> 00:34:28,280
vale

769
00:34:28,280 --> 00:34:30,599
entonces esto que tiene

770
00:34:30,599 --> 00:34:33,000
pues no es tan lento como esto

771
00:34:33,000 --> 00:34:35,179
no es tan

772
00:34:35,179 --> 00:34:37,099
eficiente como esto

773
00:34:37,099 --> 00:34:38,780
pero es multiplataforma

774
00:34:38,780 --> 00:34:41,219
entonces tú pues te descargas de internet cualquier aplicación

775
00:34:41,219 --> 00:34:43,340
Java y la puedes ejecutar sin problema

776
00:34:43,340 --> 00:34:45,039
te descargas de internet

777
00:34:45,039 --> 00:34:46,219
una aplicación hecha en C

778
00:34:46,219 --> 00:34:49,179
ya compilada y funcionará o no

779
00:34:49,179 --> 00:34:51,179
depende de si tu CPU es compatible o no

780
00:34:51,179 --> 00:34:53,239
con la versión que se compiló

781
00:34:53,239 --> 00:34:53,800
¿vale?

782
00:34:54,280 --> 00:34:59,880
Vale, bueno, pues esto es más o menos el contexto en el que trabajamos

783
00:34:59,880 --> 00:35:05,579
Entonces, nosotros arrancaremos a hacer nuestros códigos fuentes

784
00:35:05,579 --> 00:35:11,519
Haremos esta compilación y ejecutaremos con la máquina virtual

785
00:35:11,519 --> 00:35:17,559
Al principio vamos a ver cómo se hace esto, pues cómo se hace a pelos

786
00:35:17,559 --> 00:35:18,980
Es decir, cómo funcionan las cosas

787
00:35:18,980 --> 00:35:21,719
Escribo mi código fuente en un blog de notas

788
00:35:21,719 --> 00:35:24,199
lo compilo con la herramienta de compilación

789
00:35:24,199 --> 00:35:24,880
que me da Java

790
00:35:24,880 --> 00:35:28,000
y luego ya lo ejecuto con esta máquina virtual

791
00:35:28,000 --> 00:35:29,199
todo desde la consola

792
00:35:29,199 --> 00:35:31,539
recordad siempre que la consola es

793
00:35:31,539 --> 00:35:34,599
el que usa la consola es el que sabe hacer las cosas

794
00:35:34,599 --> 00:35:35,679
¿vale?

795
00:35:35,760 --> 00:35:36,920
luego ya, ¿qué ocurre?

796
00:35:37,380 --> 00:35:40,360
que tenemos software que nos ayudan

797
00:35:40,360 --> 00:35:41,599
y nos facilitan tareas

798
00:35:41,599 --> 00:35:43,659
pero que eso no nos tape

799
00:35:43,659 --> 00:35:44,940
cómo se hacen las cosas de verdad

800
00:35:44,940 --> 00:35:47,199
entonces cuando ya entendamos

801
00:35:47,199 --> 00:35:50,000
rápidamente este esquema

802
00:35:50,000 --> 00:35:51,000
de trabajo bien

803
00:35:51,000 --> 00:36:28,880
Pues ya podemos pasar a un software que se llama entorno de desarrollo. ¿Y qué son los entornos de desarrollo? Bueno, pues un entorno de desarrollo es un software muy completo y muy grande y con muchas cosas que nos permite simplemente automatizar, nos facilita algunas de las tareas relacionadas con programar.

804
00:36:28,880 --> 00:36:30,980
nos facilita algunas de las tareas

805
00:36:30,980 --> 00:36:33,239
en realidad las tareas

806
00:36:33,239 --> 00:36:35,139
involucradas con programar son

807
00:36:35,139 --> 00:36:37,119
escribir código fuente

808
00:36:37,119 --> 00:36:38,300
o sea, teclear

809
00:36:38,300 --> 00:36:40,380
teclas, código ASCII

810
00:36:40,380 --> 00:36:42,780
llamar al compilador

811
00:36:42,780 --> 00:36:44,360
y llamar a la máquina virtual

812
00:36:44,360 --> 00:36:45,400
en realidad no hay más

813
00:36:45,400 --> 00:36:48,280
pero claro, el entorno de desarrollo

814
00:36:48,280 --> 00:36:50,239
¿qué hace? pues nos mete

815
00:36:50,239 --> 00:36:52,840
un editor de texto bonito, más bonito que el blog de notas

816
00:36:52,840 --> 00:36:53,699
para que tenga colorines

817
00:36:53,699 --> 00:36:56,559
nos permite

818
00:36:56,559 --> 00:36:58,480
que se compile solo el programa

819
00:36:58,480 --> 00:37:00,260
sin tener yo que compilarlo específicamente

820
00:37:00,260 --> 00:37:01,480
lo va a compilar automáticamente

821
00:37:01,480 --> 00:37:04,840
para ejecutarlo me da un botoncito para que yo ejecute

822
00:37:04,840 --> 00:37:05,659
pues esas chorradas

823
00:37:05,659 --> 00:37:08,679
que quiero encontrar un error porque me ha dado un error

824
00:37:08,679 --> 00:37:10,619
yo he ejecutado un programa y la consola me dice

825
00:37:10,619 --> 00:37:11,579
error, no sé qué

826
00:37:11,579 --> 00:37:14,659
pues el compilador me da unas pequeñas herramientas

827
00:37:14,659 --> 00:37:15,639
de depuración

828
00:37:15,639 --> 00:37:18,099
que son herramientas que

829
00:37:18,099 --> 00:37:20,519
pues permiten en una ventanita

830
00:37:20,519 --> 00:37:22,019
aparte que tú vayas viendo

831
00:37:22,019 --> 00:37:24,039
lo que hay en cada una de tus variables

832
00:37:24,039 --> 00:37:26,519
bueno, todas estas cosas ya las iréis viendo en entornos

833
00:37:26,519 --> 00:37:27,559
de desarrollo, entonces

834
00:37:27,559 --> 00:37:30,099
un entorno de desarrollo es un software

835
00:37:30,099 --> 00:37:32,579
que nos facilita

836
00:37:32,579 --> 00:37:34,119
la tarea de

837
00:37:34,119 --> 00:37:36,300
hacer y ejecutar

838
00:37:36,300 --> 00:37:37,860
un programa de principio a fin

839
00:37:37,860 --> 00:37:40,420
ya está, pero ni programa por nosotros

840
00:37:40,420 --> 00:37:42,059
ni nada, pues hacemos nuestro programa

841
00:37:42,059 --> 00:37:44,480
y nos da botoncitos para ahorrarnos trabajo

842
00:37:44,480 --> 00:37:45,780
nada más

843
00:37:45,780 --> 00:37:47,659
pero no lo necesitamos en realidad

844
00:37:47,659 --> 00:37:49,820
pero bueno, nos facilita algunas tareas

845
00:37:49,820 --> 00:37:52,420
entornos de desarrollo

846
00:37:52,420 --> 00:37:54,260
pues hay un montón para un montón de lenguajes

847
00:37:54,260 --> 00:37:55,000
¿vale?

848
00:37:55,000 --> 00:37:57,960
para Java

849
00:37:57,960 --> 00:37:58,940
el más usado

850
00:37:58,940 --> 00:38:00,780
es Eclipse

851
00:38:00,780 --> 00:38:04,199
¿vale? que es el que usaremos nosotros

852
00:38:04,199 --> 00:38:07,940
también, pero hay muchos para Java

853
00:38:07,940 --> 00:38:09,539
está este, el NetBeans

854
00:38:09,539 --> 00:38:11,280
hay muchos entornos de desarrollo

855
00:38:11,280 --> 00:38:14,500
estos son los tres que más se usan

856
00:38:14,500 --> 00:38:15,760
¿vale? bueno este

857
00:38:15,760 --> 00:38:17,440
últimamente quizás se usa menos, pero bueno

858
00:38:17,440 --> 00:38:18,739
yo creo que es el que se usa mucho

859
00:38:18,739 --> 00:38:21,719
entonces, pues nosotros vamos a usar

860
00:38:21,719 --> 00:38:23,440
en concreto este entorno de desarrollo

861
00:38:23,440 --> 00:38:25,860
cuidado, no nos tenemos que perder

862
00:38:25,860 --> 00:38:27,380
porque el entorno de desarrollo se abre

863
00:38:27,380 --> 00:38:29,719
y parece que te hace cosas solo

864
00:38:29,719 --> 00:38:31,300
no te hace nada solo

865
00:38:31,300 --> 00:38:33,460
el entorno de desarrollo, como te meta código

866
00:38:33,460 --> 00:38:34,460
él por iniciativa propia

867
00:38:34,460 --> 00:38:36,940
lo mete mal, obviamente

868
00:38:36,940 --> 00:38:39,059
entonces cuidado

869
00:38:39,059 --> 00:38:41,579
bueno, pues usaremos este entorno

870
00:38:41,579 --> 00:38:42,800
de desarrollo nosotros

871
00:38:42,800 --> 00:38:45,119
y vamos a ver si aquí en la introducción

872
00:38:45,119 --> 00:38:46,159
teníamos algo más

873
00:38:46,159 --> 00:38:49,820
vale, aquí más o menos está lo que os he contado

874
00:38:49,820 --> 00:38:52,000
pues por si alguien se ha perdido

875
00:38:52,000 --> 00:38:53,320
pero bueno, no tiene mucho

876
00:38:53,320 --> 00:38:59,269
vale, pues ya está

877
00:38:59,269 --> 00:39:03,550
vale, a ver, bueno, lo único que no he dicho es

878
00:39:03,550 --> 00:39:07,690
lo único que no he dicho es

879
00:39:07,690 --> 00:39:09,190
en este proceso

880
00:39:09,190 --> 00:39:10,349
de desarrollo

881
00:39:10,349 --> 00:39:12,849
uno hace el código fuente

882
00:39:12,849 --> 00:39:14,489
lo compila

883
00:39:14,489 --> 00:39:17,070
lo compila si está en este proceso

884
00:39:17,070 --> 00:39:19,230
o está aquí en este, claro, lo compila

885
00:39:19,230 --> 00:39:20,989
puede ocurrir que

886
00:39:20,989 --> 00:39:22,070
den errores

887
00:39:22,070 --> 00:39:24,409
porque hayas escrito mal el código

888
00:39:24,409 --> 00:39:26,889
a lo mejor en Java tú tienes que poner

889
00:39:26,889 --> 00:39:29,050
system out y has puesto

890
00:39:29,050 --> 00:39:30,409
SystemAuth con dos t's

891
00:39:30,409 --> 00:39:32,909
has escrito mal el código, porque no has seguido

892
00:39:32,909 --> 00:39:35,329
las reglas del lenguaje, no has seguido las reglas

893
00:39:35,329 --> 00:39:37,210
pues eso se va a detectar

894
00:39:37,210 --> 00:39:38,269
en el momento de compilar

895
00:39:38,269 --> 00:39:40,869
recompilar en el caso de Java se va a detectar

896
00:39:40,869 --> 00:39:43,010
y te va a salir un error de compilación

897
00:39:43,010 --> 00:39:44,449
este programa está mal escrito

898
00:39:44,449 --> 00:39:47,590
bueno, pues nada, arreglaremos los errores de compilación

899
00:39:47,590 --> 00:39:48,050
vale

900
00:39:48,050 --> 00:39:51,590
un error que ya no tiene ningún error de compilación

901
00:39:51,590 --> 00:39:53,090
ninguno, ya puede

902
00:39:53,090 --> 00:39:55,210
pasar a ser interpretado por la máquina virtual

903
00:39:55,210 --> 00:39:56,670
cuando ya no tenga ningún error de compilación

904
00:39:56,670 --> 00:39:59,829
Que no tenga ningún error de compilación

905
00:39:59,829 --> 00:40:00,869
Significa que el programa está bien hecho

906
00:40:00,869 --> 00:40:03,429
No, habremos hecho un programa sin errores de compilación

907
00:40:03,429 --> 00:40:05,090
Pero que igual no hace lo que tiene que hacer

908
00:40:05,090 --> 00:40:05,809
Hace otra cosa

909
00:40:05,809 --> 00:40:10,150
O no solo eso, sino que nos da un error de ejecución

910
00:40:10,150 --> 00:40:11,650
Que esos son los graves

911
00:40:11,650 --> 00:40:13,590
Por ejemplo

912
00:40:13,590 --> 00:40:15,750
Mi aplicación, mi programa

913
00:40:15,750 --> 00:40:17,190
Está escrito

914
00:40:17,190 --> 00:40:19,769
En lenguaje perfecto

915
00:40:19,769 --> 00:40:20,650
No tiene ningún error

916
00:40:20,650 --> 00:40:22,630
¿Qué es lo que hace? Pide un número

917
00:40:22,630 --> 00:40:25,489
Pide otro número y te muestra la división

918
00:40:25,489 --> 00:40:26,110
De uno y otro

919
00:40:26,110 --> 00:40:28,190
perfectamente escrito, muy bien

920
00:40:28,190 --> 00:40:30,289
ahora ya entramos en fase de ejecución

921
00:40:30,289 --> 00:40:32,670
el programa te dice, introduzca un número

922
00:40:32,670 --> 00:40:34,949
7, introduzca otro número

923
00:40:34,949 --> 00:40:37,289
0, él hace 7 entre 0

924
00:40:37,289 --> 00:40:38,929
¡pam! se te ha roto

925
00:40:38,929 --> 00:40:41,070
se te ha roto porque no se puede

926
00:40:41,070 --> 00:40:41,929
dividir por 0

927
00:40:41,929 --> 00:40:44,670
es una indeterminación matemática

928
00:40:44,670 --> 00:40:45,909
no se puede dividir por 0

929
00:40:45,909 --> 00:40:48,050
entonces si no se puede dividir por 0

930
00:40:48,050 --> 00:40:50,130
en todo el cuerpo de las matemáticas

931
00:40:50,130 --> 00:40:51,429
solo se pueden hacer límites

932
00:40:51,429 --> 00:40:54,550
¿cómo va a dividir por 0 una máquina virtual, una CPU?

933
00:40:54,769 --> 00:40:55,610
por menos todavía

934
00:40:55,610 --> 00:40:59,090
entonces, ese es un ejemplo de error de ejecución

935
00:40:59,090 --> 00:41:00,710
un programa puede

936
00:41:00,710 --> 00:41:02,409
compilar perfectamente

937
00:41:02,409 --> 00:41:03,489
porque está bien escrito

938
00:41:03,489 --> 00:41:05,530
pero a la hora de ejecutarlo

939
00:41:05,530 --> 00:41:08,590
ha fallado, es un error de ejecución

940
00:41:08,590 --> 00:41:10,889
esos son los graves, porque los de compilación

941
00:41:10,889 --> 00:41:12,610
se detectan cuando tú estás ahí metido

942
00:41:12,610 --> 00:41:14,710
en tu cuarto haciendo

943
00:41:14,710 --> 00:41:16,610
pero los de ejecución se detectan

944
00:41:16,610 --> 00:41:18,250
cuando ya se ha entregado tu programa

945
00:41:18,250 --> 00:41:19,849
se lo has dado a alguien, topancho

946
00:41:19,849 --> 00:41:21,889
y él va y ¡bom! ¡oye, vaya mierda me has dado!

947
00:41:22,429 --> 00:41:23,750
esos son los graves, ¿vale?

948
00:41:23,750 --> 00:41:25,750
los más complicados de detectar

949
00:41:25,750 --> 00:41:27,210
¿cómo se detectan?

950
00:41:27,590 --> 00:41:28,469
haciendo mil pruebas

951
00:41:28,469 --> 00:41:31,710
antes de entregar un programa, haz mil pruebas

952
00:41:31,710 --> 00:41:33,349
200.000, mete mil datos

953
00:41:33,349 --> 00:41:35,289
y seguro que alguna vez te falle

954
00:41:35,289 --> 00:41:37,989
a lo mejor hicimos una prueba, le di 7

955
00:41:37,989 --> 00:41:40,409
le di 2 y me hizo la división perfecta

956
00:41:40,409 --> 00:41:42,190
uy, me ha funcionado el programa estupendamente

957
00:41:42,190 --> 00:41:43,389
¿qué te ha fallado?

958
00:41:43,530 --> 00:41:45,409
que te han faltado pruebas, muchas pruebas

959
00:41:45,409 --> 00:41:47,150
te han hecho la prueba, le doy 7 y le doy 10

960
00:41:47,150 --> 00:41:49,090
¿vale? entonces

961
00:41:49,090 --> 00:41:51,190
hay que evitar errores

962
00:41:51,190 --> 00:41:53,110
en la medida de lo posible, errores de ejecución

963
00:41:53,110 --> 00:41:55,030
haciendo todas las pruebas del programa

964
00:41:55,030 --> 00:41:57,170
una vez que ya compila

965
00:41:57,170 --> 00:41:59,429
por supuesto, los de compilación son los primeros

966
00:41:59,429 --> 00:41:59,949
¿vale?

967
00:42:00,610 --> 00:42:01,969
bueno, pues entonces

968
00:42:01,969 --> 00:42:06,530
vale, pues ya está

969
00:42:06,530 --> 00:42:08,550
de introducción en general

970
00:42:08,550 --> 00:42:11,170
al proceso de programar un poquito así

971
00:42:11,170 --> 00:42:13,050
por encima, sería esto

972
00:42:13,050 --> 00:42:14,949
a partir de aquí ya entramos ya en

973
00:42:14,949 --> 00:42:17,110
las cosas

974
00:42:17,110 --> 00:42:17,969
concretas ya

975
00:42:17,969 --> 00:42:20,010
de programación estructural

976
00:42:20,010 --> 00:42:21,590
¿alguna pregunta?

977
00:42:21,590 --> 00:42:23,650
duda, algo

978
00:42:23,650 --> 00:42:26,349
nada de nada

979
00:42:26,349 --> 00:42:28,349
todo está muy claro

980
00:42:28,349 --> 00:42:30,610
vale, pues venga

981
00:42:30,610 --> 00:42:33,090
os aseguráis de que lo tenéis todo en la cabeza

982
00:42:33,090 --> 00:42:35,469
antes de mañana