1
00:00:00,000 --> 00:00:05,839
Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a que graben vuestro.

2
00:00:07,839 --> 00:00:12,839
Primera clase, vamos a ver un poquito de introducción a la programación.

3
00:00:18,809 --> 00:00:21,670
Primera cosa, ¿qué es la programación y qué es un programa?

4
00:00:21,910 --> 00:00:25,969
Una definición así no formal, pero para que nos entendamos un poco.

5
00:00:26,089 --> 00:00:29,769
La programación consiste en la creación de un conjunto concreto de instrucciones

6
00:00:29,769 --> 00:00:34,450
que un ordenador puede interpretar denominado programa de ordenador vale entonces lo que vamos

7
00:00:34,450 --> 00:00:43,630
a hacer nosotros es crear cosas y escribir un párrafo de código raro que sustancialmente es

8
00:00:43,630 --> 00:00:49,670
una forma que tenemos para poder comunicar con nuestro ordenador y decirle que queremos que

9
00:00:49,670 --> 00:00:55,990
haga el ordenador vale a partir de allí estas cosas que escribimos este lenguaje raro que

10
00:00:55,990 --> 00:01:02,670
utilizamos es un programa el programa lo puede entender el ordenador y nosotros nos transformamos

11
00:01:02,670 --> 00:01:10,329
sustancialmente en lingüistas en personas capaces de comunicar con un ordenador y decirle que

12
00:01:10,329 --> 00:01:18,370
queremos crear si esto lo hacemos creando programas un programa se escribe normalmente en un lenguaje

13
00:01:18,370 --> 00:01:24,069
de programación pero no necesariamente este lenguaje de programación es de alto nivel es

14
00:01:24,069 --> 00:01:36,730
se puede llegar a hablar con un ordenador a nivel de ceros y unos vale tú puedes escribir un programa

15
00:01:36,730 --> 00:01:42,450
con ceros y unos hoy en día eso no se hace porque es aburrido pero si habéis visto alguna película

16
00:01:42,450 --> 00:01:48,230
vieja o cosas por el estilo había un tiempo los primeros ordenadores había una figura profesional

17
00:01:48,230 --> 00:01:55,530
de una persona que el matemático físico o matemática física que hacía el algoritmo

18
00:01:55,530 --> 00:02:03,829
lo escribía en un papel, se lo daba a esta persona que transfería en unas tarjetas perforadas

19
00:02:03,829 --> 00:02:09,969
el algoritmo, el programa que el otro se había inventado.

20
00:02:10,129 --> 00:02:12,969
Y, sustancialmente, las tarjetas perforadas eran ceros y unos.

21
00:02:13,289 --> 00:02:16,650
O sea, la perforación es un cero, si no la perforación es un uno, o al revés.

22
00:02:16,650 --> 00:02:19,430
entonces a esos tiempos se programaba en ceros y unos

23
00:02:19,430 --> 00:02:21,229
y había alguien que decía

24
00:02:21,229 --> 00:02:22,629
vale, tú quieres hacer esto

25
00:02:22,629 --> 00:02:25,150
la máquina puede interpretar solo ceros y unos

26
00:02:25,150 --> 00:02:26,330
y yo estoy en el medio

27
00:02:26,330 --> 00:02:29,629
y lo que hago es transformar lo que tú has pensado

28
00:02:29,629 --> 00:02:31,389
en un código de ceros y unos

29
00:02:31,389 --> 00:02:33,009
con el pasar del tiempo

30
00:02:33,009 --> 00:02:34,789
pues la cosa se ha ido hacia

31
00:02:34,789 --> 00:02:36,849
mayores niveles de

32
00:02:36,849 --> 00:02:39,150
abstracción hasta llegar a los

33
00:02:39,150 --> 00:02:40,569
programas que tenemos

34
00:02:40,569 --> 00:02:42,710
a los lenguajes de programación que tenemos nosotros

35
00:02:42,710 --> 00:02:44,750
ahora más adelante veremos

36
00:02:44,750 --> 00:02:46,389
cosillas de este estilo

37
00:02:46,389 --> 00:02:49,310
¿Qué más?

38
00:02:50,270 --> 00:02:51,969
Lenguaje de programación, aquí lo ven.

39
00:02:52,389 --> 00:02:57,889
Son conjuntos de símbolos y palabras claves, palabras concretas,

40
00:02:57,889 --> 00:03:03,629
que conforman una sintaxis y una forma de crear los comandos

41
00:03:03,629 --> 00:03:08,210
para que, sustancialmente, yo, utilizando lo que tengo a disposición,

42
00:03:08,430 --> 00:03:09,810
pueda elaborar un programa.

43
00:03:10,430 --> 00:03:13,789
Entonces, yo antes tengo que saber cuáles son las palabras que puedo utilizar,

44
00:03:13,789 --> 00:03:17,650
cómo se usan, en qué secuencia se pueden poner,

45
00:03:17,990 --> 00:03:21,550
una vez que sé esto, que he aprendido la sintaxis de un lenguaje de programación,

46
00:03:21,969 --> 00:03:25,849
pues he hecho la parte fácil, porque ahora lo que viene fuera

47
00:03:25,849 --> 00:03:30,250
es el pensar cómo se resuelve el problema que quiero resolver.

48
00:03:30,250 --> 00:03:33,930
Y eso es crear el algoritmo, que es la parte más compleja del programa.

49
00:03:35,930 --> 00:03:38,250
Nosotros en el primer trimestre principalmente

50
00:03:38,250 --> 00:03:42,509
nos centraremos en sintaxis, porque muchos de vosotros no han visto

51
00:03:42,509 --> 00:03:44,289
nunca un lenguaje de programación, entonces esa

52
00:03:44,289 --> 00:03:46,349
será la parte un poquito más compleja, entender

53
00:03:46,349 --> 00:03:48,669
qué quiere, cómo se

54
00:03:48,669 --> 00:03:50,469
puede mandar la

55
00:03:50,469 --> 00:03:51,469
información al

56
00:03:51,469 --> 00:03:53,849
generador

57
00:03:53,849 --> 00:03:56,810
luego paso a paso eso se volverá

58
00:03:56,810 --> 00:03:58,449
lo normal, el estándar

59
00:03:58,449 --> 00:04:00,289
y nosotros nos empecemos a centrarnos

60
00:04:00,289 --> 00:04:02,650
en proyectos un poquito más complejos, programas

61
00:04:02,650 --> 00:04:04,569
un poquito más retorcidos, un poquito

62
00:04:04,569 --> 00:04:06,509
más interesantes

63
00:04:06,509 --> 00:04:07,569
también y más potentes

64
00:04:07,569 --> 00:04:10,729
los lenguajes de programación

65
00:04:10,729 --> 00:04:12,469
pueden ser

66
00:04:12,469 --> 00:04:15,449
de distintos niveles de abstracción, digamos así.

67
00:04:16,209 --> 00:04:18,449
El más bajo en absoluto sería programar

68
00:04:18,449 --> 00:04:21,189
en ceros y unos. Ya no se programa en ceros y unos, lo hemos dicho.

69
00:04:21,649 --> 00:04:24,370
El siguiente paso sería el lenguaje máquina. El lenguaje máquina

70
00:04:24,370 --> 00:04:26,769
es como un lenguaje que

71
00:04:26,769 --> 00:04:29,810
los procesadores puedan entender directamente.

72
00:04:30,230 --> 00:04:33,829
Cada procesador tiene un conjunto de comandos

73
00:04:33,829 --> 00:04:36,649
de muy bajo nivel que se podrían

74
00:04:36,649 --> 00:04:39,870
escribir, entre comillas, directamente al procesador

75
00:04:39,870 --> 00:04:44,430
para que él entienda que tiene que hacer y trabaje, ¿vale?

76
00:04:44,629 --> 00:04:51,889
Normalmente, una parte de estos comandos son estándar,

77
00:04:52,529 --> 00:04:55,209
pero hay otras partes que cada productor,

78
00:04:55,410 --> 00:05:00,889
cada constructor, digamos, de procesadores,

79
00:05:01,410 --> 00:05:05,430
tiene su propio lenguaje máquina dedicado, ¿vale?

80
00:05:06,069 --> 00:05:10,389
Esto implicaría que si yo trabajo con un Intel de una cierta forma,

81
00:05:10,490 --> 00:05:14,069
o trabajo con un AMD de otra forma, o trabajo con un Apple de otra forma,

82
00:05:14,550 --> 00:05:19,329
pues debería conocer el lenguaje propio de ese procesador, ¿vale?

83
00:05:19,649 --> 00:05:21,689
Cosa que sería muy compleja.

84
00:05:21,810 --> 00:05:24,269
Un tempo se hacía así, pues ahora ya no, ¿vale?

85
00:05:24,269 --> 00:05:27,490
Lo que yo quiero es abstraer de lo que tengo

86
00:05:27,490 --> 00:05:32,050
y tener una forma de hacer cosas más abstractas, más a alto nivel,

87
00:05:32,050 --> 00:05:36,509
y que luego estos programas que yo escribo a más alto nivel

88
00:05:36,509 --> 00:05:39,769
se puedan ejecutar en procesadores distintos.

89
00:05:40,389 --> 00:05:45,610
Para esto, el primer paso de abstracción es el Ensemblador o Assembler en inglés.

90
00:05:46,129 --> 00:05:48,990
Esto es un pequeño lenguaje de programación

91
00:05:48,990 --> 00:05:52,069
que en vez de programar en ceros y unos

92
00:05:52,069 --> 00:05:55,509
y con comandos directamente del lenguaje máquina del propio procesador

93
00:05:55,509 --> 00:05:59,209
me abstrae un poquito.

94
00:05:59,209 --> 00:06:09,209
Entonces yo ya tengo una operación, que es la operación ADD, que lo que permite es sumar un determinado trozo de memoria con otro determinado trozo de memoria.

95
00:06:09,370 --> 00:06:13,670
Estoy siempre a muy bajo nivel, estoy trabajando con lo que son los registros de un procesador.

96
00:06:14,170 --> 00:06:19,029
La memoria más a bajo nivel, más cercana al procesador, son los registros.

97
00:06:19,430 --> 00:06:27,889
Son trocitos de memoria muy, muy, muy rápida, pero muy, muy, muy cara, que están directamente incrustados dentro de los procesadores.

98
00:06:27,889 --> 00:06:56,990
Entonces, cuando hacen las operaciones, cuando ejecutan las operaciones, los procesadores utilizan estos registros, ¿sí? Pues el ensemblador hace operaciones sobre los datos que están en el registro, ¿vale? Cargan datos en estos registros y luego lo pueden sumar, le pueden restar, le pueden mover, le pueden hacer cosas allí, pero es un primer paso de abstracción porque no es ya 0, 2 y 1, o sea, un poquito más independiente con respecto al procesador que tengo dentro,

99
00:06:56,990 --> 00:07:03,189
pero sigue siendo una cosa muy de bajo nivel, ¿vale? Eso no se suele ver, no se suele trabajar.

100
00:07:03,370 --> 00:07:11,069
Si vosotros después de esto o en algún momento de vuestra vida iréis a la universidad y haréis una carrera de informática

101
00:07:11,069 --> 00:07:17,870
en una asignatura que se llama compiladores, pues probablemente tendréis que hacer algo con el sembrador, ¿vale?

102
00:07:18,490 --> 00:07:21,990
Veremos ahora dentro de un rato qué es un compilador, ¿vale?

103
00:07:21,990 --> 00:07:31,149
y entenderemos que es traducir el lenguaje de alto nivel, como Java o lo que sea, que utilizo yo, a un ensamblador.

104
00:07:31,550 --> 00:07:39,410
Y luego el ensamblador tendrá un intérprete o algo por el estilo que transformará este lenguaje en lenguaje máquina

105
00:07:39,410 --> 00:07:43,310
y entonces el procesador podrá ejecutar ese programa.

106
00:07:44,629 --> 00:07:48,970
Pero a nosotros nos interesa el alto nivel, a nosotros nos interesa la abstracción.

107
00:07:48,970 --> 00:07:51,490
en un cierto sentido la inteligencia artificial

108
00:07:51,490 --> 00:07:53,509
misma es otro nivel de

109
00:07:53,509 --> 00:07:55,129
extracción a nivel de programación

110
00:07:55,129 --> 00:07:57,629
a nosotros nos gustaría programar

111
00:07:57,629 --> 00:07:59,370
diciendo que era un programa que

112
00:07:59,370 --> 00:08:01,689
calcula la suma de dos números

113
00:08:01,689 --> 00:08:03,389
esto, así, en

114
00:08:03,389 --> 00:08:05,589
lenguaje natural, y que el ordenador

115
00:08:05,589 --> 00:08:07,449
lo entiende y diga, vale, muy bien, esto

116
00:08:07,449 --> 00:08:09,550
ahora lo hago, que un poco

117
00:08:09,550 --> 00:08:11,290
la inteligencia artificial está yendo hacia

118
00:08:11,290 --> 00:08:13,430
esa posibilidad

119
00:08:13,430 --> 00:08:15,329
eso sería un nivel de extracción

120
00:08:15,329 --> 00:08:17,410
todavía más alto de lo que tenemos

121
00:08:17,410 --> 00:08:23,769
nosotros. Cuando hablamos de alto nivel, nosotros hablamos de lenguajes como Java, como C, como

122
00:08:23,769 --> 00:08:33,009
Python, como no lo sé, hay otros ejemplos por ahí, que me permiten describir lo que

123
00:08:33,009 --> 00:08:39,529
tiene que hacer mi programa, ¿vale? Pero totalmente independiente de lo que tengo por

124
00:08:39,529 --> 00:08:45,210
debajo a nivel de ordenador que tengo por debajo, ¿vale? Yo le explico que, oye, mira,

125
00:08:45,210 --> 00:08:51,149
quiero que me escribas en pantalla esta cosa, para hacer esto tengo que ponerle un código,

126
00:08:51,149 --> 00:08:58,049
un comando específico del lenguaje, pero luego ¿cómo se hace esto? O sea, todo el proceso de

127
00:08:58,049 --> 00:09:02,490
que el procesador tiene que entenderlo, pillar los datos que yo quiero que se imprima en pantalla,

128
00:09:02,490 --> 00:09:06,929
ir a hablar por la pantalla, decirle a la pantalla tienes que escribir esto, todo esto yo quiero que

129
00:09:06,929 --> 00:09:13,970
esté escondido. Eso es bajo nivel. Yo quiero verlo desde arriba. Yo le digo escríbeme esto ¿cómo se

130
00:09:13,970 --> 00:09:20,330
hace para escribir todo eso, pues es problema tuyo. Esto es programar en un

131
00:09:20,330 --> 00:09:25,409
cierto sentido a alto nivel. Yo me voy a centrar principalmente en el algoritmo y

132
00:09:25,409 --> 00:09:32,789
en una sintaxis mucho más parecida, mucho más vecina, cercana a la del lenguaje

133
00:09:32,789 --> 00:09:39,029
natural y no quiero molestarme con todo lo que es por debajo de él. Vete a la

134
00:09:39,029 --> 00:09:40,629
memoria a la RAM

135
00:09:40,629 --> 00:09:43,110
vete a buscar en la RAM la celda

136
00:09:43,110 --> 00:09:45,009
37, allí me pillas

137
00:09:45,009 --> 00:09:46,889
ese dato, me lo escribes en un fichero

138
00:09:46,889 --> 00:09:49,049
yo no quiero todas esas cosas, la cosa me la tiene que

139
00:09:49,049 --> 00:09:50,870
hacer alguien por debajo, yo quiero

140
00:09:50,870 --> 00:09:52,950
programar a un nivel más alto

141
00:09:52,950 --> 00:09:54,129
¿se entiende más o menos?

142
00:09:54,970 --> 00:09:56,870
nosotros trabajaremos con Java

143
00:09:56,870 --> 00:09:58,090
que está aquí

144
00:09:58,090 --> 00:10:00,789
entonces

145
00:10:00,789 --> 00:10:03,070
hay lenguajes de programación

146
00:10:03,070 --> 00:10:04,889
de alto nivel imperativos

147
00:10:04,889 --> 00:10:07,110
¿vale? los imperativos

148
00:10:07,110 --> 00:10:08,909
son sustancialmente

149
00:10:08,909 --> 00:10:15,450
lenguajes que funcionan con que yo describo lo que quiere hacer mi

150
00:10:15,450 --> 00:10:22,830
programa paso a paso. La forma de programar a nivel imperativo es hoy

151
00:10:22,830 --> 00:10:28,889
ordenador haz esto, luego haz esto, luego haz esto y si sigues todos mis pasos

152
00:10:28,889 --> 00:10:33,149
habrás cumplido el algoritmo que me hacía falta y al final tendrás un

153
00:10:33,149 --> 00:10:38,029
Un resultado, ese resultado, impríbelo en pantalla, eso es lo que yo quiero.

154
00:10:38,789 --> 00:10:38,970
¿Vale?

155
00:10:39,509 --> 00:10:41,789
Es dar comandos.

156
00:10:42,309 --> 00:10:44,509
Dar, haz esto, esto, esto, esto, en secuencia.

157
00:10:44,509 --> 00:10:45,110
¿Sí?

158
00:10:48,769 --> 00:10:56,129
Cuando estamos en un lenguaje de alto nivel, un comando solo, una línea de comando que vosotros pondréis diciendo,

159
00:10:56,129 --> 00:10:57,950
hace esta cosa, en realidad

160
00:10:57,950 --> 00:10:59,509
a bajo nivel

161
00:10:59,509 --> 00:11:01,710
puede incluir

162
00:11:01,710 --> 00:11:03,950
muchas instrucciones

163
00:11:03,950 --> 00:11:05,009
máquinas. El

164
00:11:05,009 --> 00:11:07,870
escríbeme esto en pantalla, que tú ves

165
00:11:07,870 --> 00:11:10,029
escríbeme hola en pantalla, tú ves un programa

166
00:11:10,029 --> 00:11:11,690
que te escribe hola y se acabó.

167
00:11:12,070 --> 00:11:14,149
En realidad, por debajo, a nivel

168
00:11:14,149 --> 00:11:16,129
de procesador, pues tendrá

169
00:11:16,129 --> 00:11:17,710
mucho más pasos.

170
00:11:18,470 --> 00:11:20,149
Pasos que pedirá la H.

171
00:11:20,350 --> 00:11:21,850
La H tendrá un código,

172
00:11:21,990 --> 00:11:24,070
la carga en un lado, luego pilla

173
00:11:24,070 --> 00:11:26,009
la O, luego se

174
00:11:26,009 --> 00:11:30,129
comunicará con la pantalla, le dirá, oye, mire, el driver de la pantalla tiene que escribir

175
00:11:30,129 --> 00:11:33,970
este código que se refiere a una H, etc. Todos estos programas,

176
00:11:34,309 --> 00:11:37,889
todos estos pasos, estarán a nivel bajo y nosotros no lo vemos.

177
00:11:38,289 --> 00:11:39,629
Nosotros nos quedamos.

178
00:11:42,110 --> 00:11:46,009
Lenguaje imperativo describe secuencias de operaciones a realizar para obtener un

179
00:11:46,009 --> 00:11:48,830
resultado. Entonces se programa así, a nivel imperativo.

180
00:11:50,149 --> 00:11:54,029
Mi algoritmo será una secuencia de pasos.

181
00:11:54,029 --> 00:11:55,970
Yo tengo que dividir el problema

182
00:11:55,970 --> 00:11:59,029
¿Cómo se calcula la área de un triángulo?

183
00:11:59,549 --> 00:12:00,690
Pues, algoritmo

184
00:12:00,690 --> 00:12:02,090
Pillo la base

185
00:12:02,090 --> 00:12:03,970
La multiplico por la altura

186
00:12:03,970 --> 00:12:05,370
La divido por 2

187
00:12:05,370 --> 00:12:07,950
El resultado en primera del pantalla

188
00:12:07,950 --> 00:12:09,750
Pues, te he dado 3 pasos

189
00:12:09,750 --> 00:12:12,429
Pues, esos son los pasos que tienes que seguir para hacer

190
00:12:12,429 --> 00:12:13,929
Para solucionar el problema

191
00:12:13,929 --> 00:12:15,950
Calcular la área de un triángulo

192
00:12:15,950 --> 00:12:16,409
¿Me entiendes?

193
00:12:18,909 --> 00:12:21,210
Vale, entre los lenguajes de alto nivel

194
00:12:21,210 --> 00:12:23,570
Siempre a nivel imperativo

195
00:12:23,570 --> 00:12:24,009
¿Vale?

196
00:12:24,009 --> 00:12:31,350
Tenemos programas, lenguajes no estructurados, ¿vale? Ya no se usan, pero algunos de vosotros

197
00:12:31,350 --> 00:12:37,309
podrían haber oído alguna vez el BASIC, ¿vale? Estos son programas donde sustancialmente

198
00:12:37,309 --> 00:12:48,789
la esencia, la unidad del programa es la línea de código, ¿vale? Esto es, bueno, años 80, 90, por ahí,

199
00:12:48,789 --> 00:12:50,710
donde se programaba

200
00:12:50,710 --> 00:12:53,470
programas sencillos

201
00:12:53,470 --> 00:12:55,309
no se podía hacer programas complejos

202
00:12:55,309 --> 00:12:55,870
y grandes

203
00:12:55,870 --> 00:12:58,990
y con esta

204
00:12:58,990 --> 00:13:03,029
con este tipo de lenguajes

205
00:13:03,029 --> 00:13:04,110
era suficiente

206
00:13:04,110 --> 00:13:06,289
teniendo en cuenta que

207
00:13:06,289 --> 00:13:09,409
también en informática las cosas evolucionan

208
00:13:09,409 --> 00:13:10,590
en base a la necesidad

209
00:13:10,590 --> 00:13:12,590
si yo tengo cosas muy sencillas

210
00:13:12,590 --> 00:13:14,450
pues pillaré una cosa sencilla y sigo adelante

211
00:13:14,450 --> 00:13:17,129
en cuanto las cosas se complican y se vuelven más

212
00:13:17,129 --> 00:13:21,769
difíciles, pues a lo mejor lo que tenía antes, las herramientas que tenía antes

213
00:13:21,769 --> 00:13:25,490
no son suficientes, entonces necesito desarrollar algo más

214
00:13:25,490 --> 00:13:29,629
algo quizás a un nivel un poquito más alto de extracción

215
00:13:29,629 --> 00:13:33,629
para que sostancialmente sea más fácil centrarme en lo que ahora

216
00:13:33,629 --> 00:13:35,809
es importante, no lo de antes.

217
00:13:37,409 --> 00:13:41,269
Entonces, el BASIC se basaba sobre la línea de código y tenía

218
00:13:41,269 --> 00:13:45,409
el infernal GOTU. El GOTU era un comando que me permitía

219
00:13:45,409 --> 00:13:53,629
saltar donde sea dentro de mi programa. ¿Vale? Eso era infernal porque para programas muy pequeños

220
00:13:53,629 --> 00:14:00,350
te decía tú haces esto, haces esto, haces esto y si llegas a esta línea de aquí salta la línea 900. Vale,

221
00:14:00,350 --> 00:14:06,409
tú seguías a la línea 900 y hacías esto y cuando llegas aquí salta la 37 y ibas a la 37. Programas

222
00:14:06,409 --> 00:14:14,169
pequeños más o menos ves dónde vas. Programas muy muy complejos, estos saltos que no son estructurados

223
00:14:14,169 --> 00:14:21,629
se volvían a enfermar. Los equipos eran incapaces de mantener sus propios programas.

224
00:14:21,629 --> 00:14:27,049
Hacías los programas, mientras que este equipo trabajaba, a lo mejor se entendía más o menos,

225
00:14:27,049 --> 00:14:32,990
en cuanto el equipo se iba porque cambiaba de trabajo, se jubilaba o pasaba a otro proyecto,

226
00:14:32,990 --> 00:14:38,590
alguien de fuera que llegaba a ver ese código no podía entender que se había hecho.

227
00:14:38,590 --> 00:14:43,029
con el aumentar de la complejidad de los programas

228
00:14:43,029 --> 00:14:45,649
pues llegaron a ser estructurados

229
00:14:45,649 --> 00:14:47,690
como por ejemplo el lenguaje C

230
00:14:47,690 --> 00:14:48,850
que a lo mejor conocéis

231
00:14:48,850 --> 00:14:51,090
es como el abuelo de C++

232
00:14:51,090 --> 00:14:53,529
o Pascal

233
00:14:53,529 --> 00:14:58,190
en estos de aquí la base, la unidad

234
00:14:58,190 --> 00:15:00,330
no es tanto la línea de código

235
00:15:00,330 --> 00:15:02,450
cuanto la función en los módulos

236
00:15:02,450 --> 00:15:04,110
o funciones y proceduras

237
00:15:04,110 --> 00:15:09,490
Sostancialmente se dan bloques de líneas de códigos

238
00:15:09,490 --> 00:15:11,409
A las que se le da un nombre

239
00:15:11,409 --> 00:15:17,090
Esta es una función que se llama calcular el triángulo

240
00:15:17,090 --> 00:15:21,169
Donde dentro están todos los comandos para calcular el triángulo

241
00:15:21,169 --> 00:15:24,429
Luego estará una función que es calcular el cuadrado

242
00:15:24,429 --> 00:15:26,669
Donde estarán todas las funciones de calcular el cuadrado

243
00:15:26,669 --> 00:15:29,269
Cuando ahora hago mi programa matemática

244
00:15:29,269 --> 00:15:31,169
Que permite hacer muchas cosas

245
00:15:31,169 --> 00:15:33,309
Entre ellas calcular el triángulo

246
00:15:33,309 --> 00:15:37,529
de calcular la área del cuadrado, pues tengo una estructuración.

247
00:15:38,190 --> 00:15:43,210
No tengo todo mezclado en líneas de códigos retorcidos entre ellos

248
00:15:43,210 --> 00:15:44,490
y saltos por aquí y por allá.

249
00:15:44,769 --> 00:15:47,250
Tengo todo lo que es calcular la área del triángulo

250
00:15:47,250 --> 00:15:50,250
bien empaquetado en una función concreta.

251
00:15:50,250 --> 00:15:51,789
Y el cuadrado en otra.

252
00:15:52,210 --> 00:15:53,870
Y el círculo en otra.

253
00:15:54,350 --> 00:15:58,289
Entonces, esto me permite hacer muchas cosas.

254
00:15:58,769 --> 00:16:03,190
Primero, entender más programas complejos.

255
00:16:03,309 --> 00:16:11,190
organizarlos mejor, segundo, poder compartir trabajo, ¿vale?

256
00:16:11,210 --> 00:16:15,409
Porque yo puedo decir que yo hago el programa que gestionará todas estas funciones

257
00:16:15,409 --> 00:16:20,870
y a un grupo de trabajo le doy la parte que se ocupe de todo el triángulo.

258
00:16:21,009 --> 00:16:24,870
Vosotros vais a desarrollar todas las funciones relacionadas con el triángulo.

259
00:16:25,230 --> 00:16:28,090
A otro grupo, todos los que son el cuadrado.

260
00:16:28,190 --> 00:16:30,070
A otro grupo, todo el cubo.

261
00:16:30,070 --> 00:16:45,789
Entonces, de esta forma, es más fácil luego, una vez que cada uno ha hecho su trabajo, recolectarlo todo porque yo haré como interfaz a los demás, no su código que tendré que incrustar en mi código,

262
00:16:46,230 --> 00:16:50,149
sino simplemente haré llamadas a las funciones cuando las necesitaré.

263
00:16:50,149 --> 00:16:54,629
tengo que calcularla de un triángulo, llamaré la función calcularla de triángulo

264
00:16:54,629 --> 00:17:00,429
que dentro tendrá el algoritmo, los procedimientos, los pasos para calcularla de 10.

265
00:17:01,110 --> 00:17:01,909
¿Se entiende más o menos?

266
00:17:04,730 --> 00:17:09,569
Aún así, no es tan fácil analizar y diseñar, ¿vale?

267
00:17:09,670 --> 00:17:16,109
Es más fácil que si usas un estructurado, pero aún así se vuelve un poquito complejo

268
00:17:16,109 --> 00:17:19,230
siempre cuando el problema escala, ¿vale?

269
00:17:19,230 --> 00:17:26,349
Escalar un problema quiere decir ir a más dificultad, con más datos, con más cosas a tener en cuenta, pues la cosa se complica.

270
00:17:26,930 --> 00:17:31,130
Entonces, cambiaron de paradigma hacia la orientación a objetos.

271
00:17:31,569 --> 00:17:35,910
La orientación a objetos es como una estructuración de más alto nivel.

272
00:17:37,150 --> 00:17:43,009
Entonces, lo que se hace cuando se orienta a objetos es construir, identificar clases.

273
00:17:43,009 --> 00:17:52,029
Estas clases definen, modelizan una parte de mi programa

274
00:17:52,029 --> 00:17:56,950
Por ejemplo, yo si tengo una escuela, tendré una clase que modeliza el alumno

275
00:17:56,950 --> 00:17:58,930
Una clase que modeliza el aula

276
00:17:58,930 --> 00:18:01,190
Una clase que modeliza el profesor

277
00:18:01,190 --> 00:18:07,509
En cada una de estas clases pondré la información relacionada con ese propio agente

278
00:18:07,509 --> 00:18:12,569
O sea, el alumno tendrá su nombre, tendrá su DNI, tendrá sus notas, por ejemplo

279
00:18:12,569 --> 00:18:25,470
El profesor las notas no las tendrá, porque el profesor no tiene notas. El profesor tendrá una lista de asignaturas que imparte, por ejemplo, y las asignaturas podrían tener una lista de alumnos que están cursando esa asignatura.

280
00:18:25,470 --> 00:18:43,430
Y así, así, así. Lo que estoy haciendo es poder, digamos, diseñar la aplicación a un nivel más abstracto, dividirla en bloques, que son estas clases, que luego interactuarán entre ellas.

281
00:18:43,430 --> 00:19:04,069
Cada una de estas clases, además de los datos propios, tendrá lo que se llama un comportamiento, una serie de métodos, una serie de funciones, que pero son propias de esa clase. O sea, el alumno tendrá la función estudiar, porque el alumno estudia, pero no tendrá la función impartir clase. Esa es la nueva función del profesor.

282
00:19:04,069 --> 00:19:08,069
el aula podría tener

283
00:19:08,069 --> 00:19:09,910
la función limpiar aula

284
00:19:09,910 --> 00:19:11,390
que se llama una vez al día

285
00:19:11,390 --> 00:19:13,769
al final del... no sé si me explico

286
00:19:13,769 --> 00:19:15,190
entonces

287
00:19:15,190 --> 00:19:17,710
lo que se intenta hacer es

288
00:19:17,710 --> 00:19:20,190
mejorar la capacidad

289
00:19:20,190 --> 00:19:22,410
de diseño y reutilización del código

290
00:19:22,410 --> 00:19:24,289
para que se puedan hacer

291
00:19:24,289 --> 00:19:26,190
programas mucho más complejos

292
00:19:26,190 --> 00:19:28,650
y sea más fácil organizarnos

293
00:19:28,650 --> 00:19:29,930
y entender

294
00:19:29,930 --> 00:19:32,049
qué se quiere hacer, la análisis

295
00:19:32,049 --> 00:19:34,549
dividirla y organizar

296
00:19:34,549 --> 00:19:36,109
las varias componentes del

297
00:19:36,109 --> 00:19:38,190
programa y del

298
00:19:38,190 --> 00:19:39,890
proceso para que funcione

299
00:19:39,890 --> 00:19:41,809
y sobre todo si mañana

300
00:19:41,809 --> 00:19:43,789
en vez de una escuela como la nuestra

301
00:19:43,789 --> 00:19:45,970
hago otra escuela de otro tipo

302
00:19:45,970 --> 00:19:48,009
pues toda la parte que

303
00:19:48,009 --> 00:19:49,950
pueda reutilizar la pueda

304
00:19:49,950 --> 00:19:52,049
ya utilizar en el nuevo proyecto

305
00:19:52,049 --> 00:19:54,089
sin tener que volver a desarrollarla

306
00:19:54,089 --> 00:19:56,250
desde cero. Eso me ahorra costes

307
00:19:56,250 --> 00:19:58,009
me ahorra problemas, me ahorra

308
00:19:58,009 --> 00:20:00,029
también en expertise porque

309
00:20:00,029 --> 00:20:01,630
probablemente quien ha hecho este programa

310
00:20:01,630 --> 00:20:03,750
ya ha aprendido el problema

311
00:20:03,750 --> 00:20:05,009
y ha hecho un buen trabajo

312
00:20:05,009 --> 00:20:07,029
entonces yo reutilizo su trabajo

313
00:20:07,029 --> 00:20:09,109
sin tener que volver desde cero

314
00:20:09,109 --> 00:20:10,450
a entender cuál es el problema

315
00:20:10,450 --> 00:20:13,269
y hacer los errores

316
00:20:13,269 --> 00:20:15,569
que a lo mejor él ya ha cometido y solucionado

317
00:20:15,569 --> 00:20:17,349
dudas

318
00:20:17,349 --> 00:20:22,619
existen pero

319
00:20:22,619 --> 00:20:25,019
otros tipos de lenguaje de programaciones

320
00:20:25,019 --> 00:20:26,359
que son los lenguajes de programaciones

321
00:20:26,359 --> 00:20:27,500
declarativos

322
00:20:27,500 --> 00:20:30,180
antes eran imperativos

323
00:20:30,180 --> 00:20:31,579
ahora son declarativos

324
00:20:31,579 --> 00:20:34,039
la diferencia es que en mente de imperativos

325
00:20:34,039 --> 00:20:37,839
yo le digo, haz esto, haz esto, haz esto, y tendrás la solución.

326
00:20:38,000 --> 00:20:43,319
O sea, le explico cómo quiero que se hagan los pasos para llegar a una solución.

327
00:20:43,940 --> 00:20:49,700
En el declarativo, la idea es que yo describo lo que quiero como resultado.

328
00:20:50,119 --> 00:20:52,299
No cómo se llega a ese resultado.

329
00:20:52,819 --> 00:20:59,420
Te digo lo que yo quiero al final, y luego tú, de alguna forma, lo sacas.

330
00:20:59,420 --> 00:21:01,960
En el imperativo te digo

331
00:21:01,960 --> 00:21:03,640
Tú pillas

332
00:21:03,640 --> 00:21:06,720
No es exactamente así

333
00:21:06,720 --> 00:21:07,619
Pero tené entendido

334
00:21:07,619 --> 00:21:09,680
Pilla la base, pilla la altura

335
00:21:09,680 --> 00:21:11,759
La multiplicas entre ellos, divide por dos

336
00:21:11,759 --> 00:21:12,900
Todos los pasos

337
00:21:12,900 --> 00:21:14,579
Has obtenido el área del triángulo

338
00:21:14,579 --> 00:21:16,579
En un declarativo

339
00:21:16,579 --> 00:21:18,579
No es exactamente así, pero entendedme

340
00:21:18,579 --> 00:21:19,680
Yo le diría

341
00:21:19,680 --> 00:21:22,279
Quiero tener el área de un triángulo

342
00:21:22,279 --> 00:21:24,759
Es sustancialmente lo que está aquí dentro

343
00:21:24,759 --> 00:21:26,460
Digo un triángulo

344
00:21:26,460 --> 00:21:27,180
Y digo aquí

345
00:21:27,180 --> 00:21:28,759
¿vale? y él

346
00:21:28,759 --> 00:21:31,140
mágicamente lo hace

347
00:21:31,140 --> 00:21:33,500
¿vale? ahora, está claro que

348
00:21:33,500 --> 00:21:35,119
hay campos

349
00:21:35,119 --> 00:21:37,140
en el que el imperativo

350
00:21:37,140 --> 00:21:39,599
es mucho más cómodo de utilizar

351
00:21:39,599 --> 00:21:41,579
como por ejemplo calcularlo en un triángulo

352
00:21:41,579 --> 00:21:43,460
y el declarativo es súper

353
00:21:43,460 --> 00:21:45,140
complejo porque no lo entendería un

354
00:21:45,140 --> 00:21:46,619
lo que acabo de decir

355
00:21:46,619 --> 00:21:48,400
un ordenador no lo va a entender

356
00:21:48,400 --> 00:21:51,380
pero hay otros campos donde va al revés

357
00:21:51,380 --> 00:21:52,859
¿vale? un ejemplo

358
00:21:52,859 --> 00:21:55,140
que a lo mejor algunos de vosotros

359
00:21:55,140 --> 00:21:56,700
ha oído de

360
00:21:56,700 --> 00:21:58,700
lenguaje declarativo es

361
00:21:58,700 --> 00:21:59,579
SQL.

362
00:22:00,640 --> 00:22:03,039
SQL es un lenguaje de consultas

363
00:22:03,039 --> 00:22:04,339
para bases de datos.

364
00:22:05,140 --> 00:22:07,079
Si vosotros habéis visto alguna vez en vuestra

365
00:22:07,079 --> 00:22:08,180
vida una query SQL,

366
00:22:09,079 --> 00:22:11,559
sustancialmente es, selecciona

367
00:22:11,559 --> 00:22:12,900
los campos

368
00:22:12,900 --> 00:22:14,880
nombre de una tabla

369
00:22:14,880 --> 00:22:17,140
de alumnos ordenados

370
00:22:17,140 --> 00:22:17,579
por

371
00:22:17,579 --> 00:22:20,779
en orden alfabético.

372
00:22:22,099 --> 00:22:23,059
Tú no estás diciendo

373
00:22:23,059 --> 00:22:24,660
cómo hacer esas cosas.

374
00:22:24,660 --> 00:22:30,839
Estás diciendo lo que quieres y al final quiero un listado de nombres de alumnos ordenados alfabéticamente.

375
00:22:31,220 --> 00:22:37,519
Estoy describiendo el resultado. Luego, ¿cómo tú llegas a ese resultado? El problema es tuyo.

376
00:22:37,839 --> 00:22:46,359
Habrá un sistema gestor de base de datos que interpretará lo que tú quieres como solución final y hará los pasos dentro para llegar a esa cosa.

377
00:22:46,839 --> 00:22:52,740
Pero si es declarativo, en un cierto sentido, tú estás pidiendo lo que quieres al final, no cómo se llega a ese final.

378
00:22:52,740 --> 00:22:57,460
En imperativo estás describiendo los pasos para llegar a lo que tú quieres.

379
00:22:58,079 --> 00:22:58,680
¿Se entiende la diferencia?

380
00:23:00,480 --> 00:23:00,740
Vale.

381
00:23:01,420 --> 00:23:05,500
Otros lenguajes declarativos son, por ejemplo, lisp o prolog.

382
00:23:06,599 --> 00:23:11,299
Aquí siempre cuento mi experiencia personal.

383
00:23:11,599 --> 00:23:18,059
Cuando en la prehistoria yo era estudiante de informática y vine aquí a la UPM, en Erasmus,

384
00:23:18,059 --> 00:23:22,279
pues me pusieron junto con otra chica

385
00:23:22,279 --> 00:23:25,039
a hacer un programa de elaboración

386
00:23:25,039 --> 00:23:26,160
de lenguaje natural, ¿vale?

387
00:23:26,559 --> 00:23:28,259
Entonces estábamos haciendo esta asignatura

388
00:23:28,259 --> 00:23:31,539
nos dieron un ejercicio, no me acuerdo

389
00:23:31,539 --> 00:23:35,039
pero tenías que analizar algunas palabras

390
00:23:35,039 --> 00:23:37,079
sacar algunos patrones y cosas por el estilo.

391
00:23:37,200 --> 00:23:39,000
Yo me puse a hacerlo en Java, ¿vale?

392
00:23:39,460 --> 00:23:41,480
Me tiré un par de horas de Java

393
00:23:41,480 --> 00:23:44,339
hice una cantidad de código así

394
00:23:44,339 --> 00:23:44,940
¡pa, pa, pa!

395
00:23:45,059 --> 00:23:47,099
Lancé el programa, funcionaba perfectamente.

396
00:23:47,099 --> 00:24:00,140
Mi compañera, pues estábamos en la misma práctica, dijo, mira, se puso con Prolog, si no me equivoco, y en tres líneas de código me hizo lo mismo que hacía mi programa y quizás más rápido.

397
00:24:01,200 --> 00:24:15,559
Simplemente porque en ese contexto, en esa práctica, la programación declarativa habría sido una solución mucho mejor con respecto a la programación imperativa.

398
00:24:15,559 --> 00:24:19,200
solo que yo la programación declarativa a ese tiempo no sabía ni siquiera que existía

399
00:24:19,200 --> 00:24:21,240
y por lo tanto ella sí

400
00:24:21,240 --> 00:24:26,819
la idea es que uno es mejor uno es peor

401
00:24:26,819 --> 00:24:30,000
depende del campo en el que estás trabajando

402
00:24:30,000 --> 00:24:34,420
estos de aquí son programaciones lógicas y funcionales

403
00:24:34,420 --> 00:24:39,500
utilizan funciones y funciones lógicas

404
00:24:39,500 --> 00:24:43,440
de una forma mucho más dinámica

405
00:24:43,440 --> 00:24:47,240
con respecto a lo que lo utiliza la programación imperativa,

406
00:24:47,700 --> 00:24:49,819
nosotros emprenderemos programación imperativa,

407
00:24:50,079 --> 00:24:53,200
que es lo más normal allí afuera.

408
00:24:54,599 --> 00:24:59,279
Digamos que un 75% quizás de programas que se hacen allí afuera

409
00:24:59,279 --> 00:25:04,099
para la empresa, para navegación, internet, cosas por el estilo,

410
00:25:04,400 --> 00:25:05,619
son programación imperativa.

411
00:25:06,299 --> 00:25:10,519
Estos entran más en cosas, por ejemplo, ahora con la inteligencia artificial,

412
00:25:10,519 --> 00:25:16,960
ahora con algunos campos de procesamiento de vídeo de Maré,

413
00:25:17,079 --> 00:25:23,259
pues estas cosas pueden salir porque permiten cosas que el lenguaje imperativo no permite.

414
00:25:24,119 --> 00:25:27,559
Pero, por ejemplo, justo para eso, las últimas versiones,

415
00:25:27,579 --> 00:25:30,319
y por último entiendo ya desde un rato, versiones de Java,

416
00:25:31,259 --> 00:25:36,940
han empezado a construir la posibilidad de hacer pequeñas cosas declarativas

417
00:25:36,940 --> 00:25:47,019
dentro de un marco imperativo hay algunas lo veremos algunas pinceladas más mucho más adelante

418
00:25:47,019 --> 00:25:56,380
en el curso hay algunos comandos algunas sintaxis para que el lenguaje java que es imperativo se

419
00:25:56,380 --> 00:26:02,900
porte más como declarativo en general por tiempo de entender algo de programación podemos pasar

420
00:26:02,900 --> 00:26:17,029
como parámetro en vez que un dato, una función. Entonces, códigos. Este de aquí es cálculo de la

421
00:26:17,029 --> 00:26:25,170
serie de Fibonacci. ¿Qué es la serie de Fibonacci? Es 1, 1 y luego el siguiente número es la suma de

422
00:26:25,170 --> 00:26:34,250
los dos anteriores. Entonces, 1, 1, 2, porque 2 es 1 más 1. 3, porque 2 más 1. 3 más 2, 5. 5 más 3, 8.

423
00:26:34,250 --> 00:26:39,430
esa es la serie Fibonacci. Entonces tú puedes hacer un programita que dice

424
00:26:39,430 --> 00:26:48,569
cálculame el veintisietésimo número de la serie Fibonacci. Este de aquí es

425
00:26:48,569 --> 00:26:54,589
cómo saldría el cálculo del número n de la serie Fibonacci en Ensembler,

426
00:26:54,589 --> 00:26:59,849
Assemblador. ¿Vale? ¿Lo explicáis?

427
00:26:59,849 --> 00:27:13,160
Ah, tengo que recordar que el año pasado cuando hacía zoom, luego se veía mal en la grabación,

428
00:27:13,160 --> 00:27:20,200
por lo tanto no lo hago, luego lo pruebo. Pero bueno, ¿cuánto lo tenéis allí? Si os fijáis,

429
00:27:20,200 --> 00:27:30,180
estos comandos de aquí te están diciendo mueve el registro 0, mueve registro 1, mueve registro 2

430
00:27:30,180 --> 00:27:32,420
dentro del registro 1, hace cosas

431
00:27:32,420 --> 00:27:34,420
raras, ¿vale? pero esto es

432
00:27:34,420 --> 00:27:36,380
un lenguaje de programación de lo que

433
00:27:36,380 --> 00:27:38,220
hemos visto antes, no el lenguaje máquina

434
00:27:38,220 --> 00:27:40,359
el siguiente nivel, el primer nivel de abstracción

435
00:27:40,359 --> 00:27:42,380
esto sería como se hace el Fibonacci

436
00:27:42,380 --> 00:27:43,420
en

437
00:27:43,420 --> 00:27:46,359
en Semblador, ahora si yo lo

438
00:27:46,359 --> 00:27:48,000
miro así, tengo una idea

439
00:27:48,000 --> 00:27:49,960
es complejo de entender

440
00:27:49,960 --> 00:27:52,200
entender y programar

441
00:27:52,200 --> 00:27:54,079
en Semblador es complejo

442
00:27:54,079 --> 00:27:56,240
porque no hay nada aquí que me hace

443
00:27:56,240 --> 00:27:58,339
aparte de los comentarios que son las partes

444
00:27:58,339 --> 00:28:00,400
en verde, si yo quitarlo a la parte

445
00:28:00,400 --> 00:28:02,460
en verde, pues se entiende mal, no se entiende

446
00:28:02,460 --> 00:28:03,539
ni siquiera lo que está haciendo.

447
00:28:04,599 --> 00:28:06,319
Porque es de muy bajo nivel.

448
00:28:06,980 --> 00:28:08,299
Entonces vamos a ver lo mismo

449
00:28:08,299 --> 00:28:09,460
en C

450
00:28:09,460 --> 00:28:11,039
o en Python.

451
00:28:12,720 --> 00:28:14,359
Esto de aquí, hacen

452
00:28:14,359 --> 00:28:16,339
lo mismo que antes, pero ves

453
00:28:16,339 --> 00:28:18,279
ahora, por ejemplo, en C, yo tengo

454
00:28:18,279 --> 00:28:20,059
comandos que son printf,

455
00:28:20,440 --> 00:28:22,140
print, imprimir,

456
00:28:22,539 --> 00:28:24,220
pues son cosas que me imprime estas

457
00:28:24,220 --> 00:28:26,220
cosas en pantalla. Scan

458
00:28:26,220 --> 00:28:28,160
es de leer, ¿vale?

459
00:28:28,160 --> 00:28:30,920
Esto de aquí sirve para leer un número desde teclado.

460
00:28:31,299 --> 00:28:35,319
Entonces, este de aquí, por, diga, hazme esto.

461
00:28:36,400 --> 00:28:44,000
Son palabras, son formas de escribir que no es lenguaje natural, no es castellano, no es inglés,

462
00:28:44,519 --> 00:28:47,799
pero se acerca un poquito, se entiende un poquito más.

463
00:28:47,940 --> 00:28:53,039
Es más compacto porque cada una de estas instrucciones en realidad corresponderá

464
00:28:53,039 --> 00:28:58,000
a varios bloques de programación en el sembrador.

465
00:28:58,160 --> 00:29:07,319
pero esto ya lo entiendo un poquito más vale es de más alto nivel esto es python vale si os fijáis

466
00:29:07,319 --> 00:29:14,579
no tiene nada que ver uno con otro vale son formas de escribir las cosas distintas tienen

467
00:29:14,579 --> 00:29:21,500
la sintaxis distintas algunas cosas uno será más fácil algunas cosas más difíciles pero

468
00:29:21,500 --> 00:29:32,660
Pero, de su modo, Python tiene la... yo no lo conozco muy bien, Pablo, pero tiene la fama de ser bastante sencillo de aprender, ¿vale?

469
00:29:32,960 --> 00:29:39,920
Entonces, probablemente, entender esto es mucho más fácil que otras cosas.

470
00:29:40,339 --> 00:29:43,500
Esto es Fibonacci en Prologue en Lisp.

471
00:29:44,859 --> 00:29:48,339
¿Veis? Es todavía más pequeño.

472
00:29:48,339 --> 00:29:54,660
Aquí, para entenderlo de otro modo, te estoy diciendo que si buscas Fibonacci de 0,

473
00:29:55,440 --> 00:29:58,180
o sea, el elemento 0 de Fibonacci, te doy 0.

474
00:29:58,740 --> 00:30:02,759
Si buscas Fibonacci de 1, te doy 1, ¿vale?

475
00:30:03,220 --> 00:30:05,119
Que son los dos casos bases.

476
00:30:05,640 --> 00:30:10,839
Y a partir de aquí, si me das el número n, te devuelvo el número y.

477
00:30:11,299 --> 00:30:13,200
¿Cómo está calculado el número y?

478
00:30:13,200 --> 00:30:29,819
Si n es mayor que 1, entonces suma n1 más n2, que se calculan aquí, que son el mismo Fibonacci calculado sobre el anterior.

479
00:30:34,279 --> 00:30:38,220
Pero en vez de ir acumulando y cosas por el estilo, hace cosas.

480
00:30:38,799 --> 00:30:44,880
Esta se llama recursividad, que es llamar la misma función de Fibonacci dentro de la definición.

481
00:30:44,880 --> 00:30:47,319
son cosas más

482
00:30:47,319 --> 00:30:49,099
complejas, sobre todo a este nivel

483
00:30:49,099 --> 00:30:50,720
normal que no lo entendas

484
00:30:50,720 --> 00:30:51,859
¿vale?

485
00:30:52,859 --> 00:30:55,519
esto en vez de decir una función Fibonacci

486
00:30:55,519 --> 00:30:57,119
que hace cosas raras

487
00:30:57,119 --> 00:30:58,980
y cosas por el estilo, aquí también está

488
00:30:58,980 --> 00:31:01,180
utilizando recursividad para poder hacer

489
00:31:01,180 --> 00:31:03,200
¿sí? pues cada

490
00:31:03,200 --> 00:31:05,119
uno tiene sus ventajas y sus

491
00:31:05,119 --> 00:31:06,039
desventajas

492
00:31:06,039 --> 00:31:08,960
entonces, resumiendo

493
00:31:08,960 --> 00:31:11,059
hasta aquí, hay lenguajes de programación

494
00:31:11,059 --> 00:31:13,099
a nosotros nos interesa el lenguaje de programación de alto

495
00:31:13,099 --> 00:31:18,859
nivel, hay distintos tipos de lenguaje de programación de alto nivel, en particular

496
00:31:18,859 --> 00:31:25,099
hay imperativos y declarativos. A nosotros nos interesan más los imperativos. Dentro

497
00:31:25,099 --> 00:31:30,299
de los imperativos hay no estructurados, estructurados y orientados a objetos. A nosotros nos interesan

498
00:31:30,299 --> 00:31:38,440
los orientados a objetos. ¿Estamos colocados más o menos en el sitio correcto? Siguiente

499
00:31:38,440 --> 00:31:48,140
Este concepto, compilación e interpretación, para que un lenguaje de alto nivel funcione, yo tengo dos posibilidades.

500
00:31:48,980 --> 00:31:53,500
O lo compilo o lo interpreto. Una de las dos opciones.

501
00:31:55,299 --> 00:31:57,779
Esto siempre estamos hablando de lenguaje de alto nivel.

502
00:31:57,779 --> 00:32:03,660
Si yo tengo un lenguaje como un lenguaje máquina que trabaja directamente con el procesador,

503
00:32:03,660 --> 00:32:04,920
allí no hay interpretación

504
00:32:04,920 --> 00:32:07,440
ni compilación

505
00:32:07,440 --> 00:32:08,680
allí funciona directamente

506
00:32:08,680 --> 00:32:10,960
pero si yo tengo un lenguaje de alto nivel

507
00:32:10,960 --> 00:32:12,660
tengo esta cosa aquí

508
00:32:12,660 --> 00:32:14,440
¿vale?

509
00:32:15,119 --> 00:32:17,640
necesito que alguien transforme

510
00:32:17,640 --> 00:32:18,359
esto

511
00:32:18,359 --> 00:32:20,920
en ceros y unos

512
00:32:20,920 --> 00:32:23,180
que el procesador pueda entender

513
00:32:23,180 --> 00:32:24,720
¿vale?

514
00:32:25,140 --> 00:32:26,420
el proceso

515
00:32:26,420 --> 00:32:29,359
que pilla un lenguaje de programación

516
00:32:29,359 --> 00:32:31,200
de alto nivel y lo

517
00:32:31,200 --> 00:32:33,299
transforma en una secuencia

518
00:32:33,299 --> 00:32:39,180
de ceros y unos, que serán comandos propios del procesador para que se puedan ejecutar

519
00:32:39,180 --> 00:32:45,839
en el procesador, se llama o compilación, veremos ahora qué es exactamente, o interpretación.

520
00:32:46,220 --> 00:32:51,220
Dependiendo de cómo hago este proceso, estoy compilando o estoy interpretando.

521
00:32:53,519 --> 00:33:00,240
Entonces, ¿qué es un intérprete? Un intérprete es un programa que funciona por su cuenta.

522
00:33:00,240 --> 00:33:03,839
alguien ya ha creado este programa y este programa está funcionando

523
00:33:03,839 --> 00:33:07,660
al que yo le paso comando por comando

524
00:33:07,660 --> 00:33:11,799
las líneas de mi programa, es decir

525
00:33:11,799 --> 00:33:16,400
le paso primero esta línea de aquí, luego esta línea de aquí

526
00:33:16,400 --> 00:33:19,880
luego esta línea de aquí, y el intérprete

527
00:33:19,880 --> 00:33:23,099
recibe como input esta

528
00:33:23,099 --> 00:33:28,759
línea de código, la transforma en ceros y unos

529
00:33:28,759 --> 00:33:33,279
en varias operaciones de lenguaje máquina

530
00:33:33,279 --> 00:33:40,819
que pueden ser interpretadas por el procesador

531
00:33:40,819 --> 00:33:44,779
y se la da al procesador para que la ejecute.

532
00:33:45,339 --> 00:33:50,940
Un intérprete es un programa que recibe en input, en entrada,

533
00:33:51,660 --> 00:33:58,640
líneas de comando, líneas de código de un lenguaje de alto nivel

534
00:33:58,640 --> 00:34:07,339
y lo traduce, lo interpreta en ceros y unos que son ejecutables por el procesador.

535
00:34:09,860 --> 00:34:15,679
El intérprete es un programa, es algo que tiene que ser ejecutado, ¿vale?

536
00:34:15,760 --> 00:34:19,659
Entonces alguien tiene que, antes de haber creado un programa de alguna forma,

537
00:34:20,039 --> 00:34:23,599
haber creado los ceros y unos interpretables por un procesador

538
00:34:23,599 --> 00:34:26,960
y decir, ok, procesador, empieza a trabajar con este programa.

539
00:34:26,960 --> 00:34:29,739
Ahora yo tengo un proceso que está en ejecución

540
00:34:29,739 --> 00:34:31,699
En el procesador

541
00:34:31,699 --> 00:34:32,940
Está funcionando

542
00:34:32,940 --> 00:34:35,179
Y empieza a decirle, haz esta cosa

543
00:34:35,179 --> 00:34:36,920
En lenguaje a alto nivel

544
00:34:36,920 --> 00:34:38,940
Y él lo traduce en 0x1 y se lo ejecuta

545
00:34:38,940 --> 00:34:40,079
Ahora haz esta cosa

546
00:34:40,079 --> 00:34:41,780
Y él 0x1 y se lo ejecuta

547
00:34:41,780 --> 00:34:43,619
Haz esta otra, etc, etc

548
00:34:43,619 --> 00:34:45,760
¿Entienden un intérprete?

549
00:34:46,519 --> 00:34:46,880
Vale

550
00:34:46,880 --> 00:34:48,559
¿Qué es en vez de un compilador?

551
00:34:49,400 --> 00:34:51,039
Un compilador es otro programita

552
00:34:51,039 --> 00:34:52,719
Que pero

553
00:34:52,719 --> 00:34:56,159
Lo que hace es pillar todo el código de alto nivel

554
00:34:56,159 --> 00:34:56,719
De golpe

555
00:34:56,719 --> 00:35:06,139
yo le paso el programa entero él lo analiza lo machaca entero todas las líneas y a partir del

556
00:35:06,139 --> 00:35:14,159
programa que le he dado yo genera una versión que hace lo mismo pero todos en ceros y uno

557
00:35:15,639 --> 00:35:22,760
mientras el intérprete pillaba una línea y la traduce y ya trae línea en la traduce linterna

558
00:35:22,760 --> 00:35:29,599
El compilador pilla el programa entero y me da como output otro programa entero, pero escrito en ceros y unos.

559
00:35:30,000 --> 00:35:31,820
Lo que se llama un ejecutable.

560
00:35:32,539 --> 00:35:36,360
Lo que vosotros habéis visto alguna vez en vuestra vida como .exe.

561
00:35:37,619 --> 00:35:43,039
Un .exe, sustancialmente, es un programa compilado.

562
00:35:43,940 --> 00:35:49,599
Había alguien escrito un programa en algún lenguaje de programación, le ha dado al compilador,

563
00:35:49,599 --> 00:35:51,679
El compilador ha sacado este fichero

564
00:35:51,679 --> 00:35:53,019
Lo llamamos .exe

565
00:35:53,019 --> 00:35:54,159
Y es ejecutable

566
00:35:54,159 --> 00:35:55,699
Porque si yo le doy doble clic

567
00:35:55,699 --> 00:35:58,480
El procesador leerá esos ceros y unos

568
00:35:58,480 --> 00:36:00,360
Y como son lenguaje máquina

569
00:36:00,360 --> 00:36:02,980
Lo puedes ejecutar directamente

570
00:36:02,980 --> 00:36:07,559
¿Entiendes?

571
00:36:12,630 --> 00:36:13,869
Proceso de compilación

572
00:36:13,869 --> 00:36:15,530
Yo tengo un programa en C

573
00:36:15,530 --> 00:36:17,949
Por ejemplo, esto es basado sobre C

574
00:36:17,949 --> 00:36:22,550
Porque típicamente C es un lenguaje de programación compilado

575
00:36:22,550 --> 00:36:25,289
Por lo tanto, cuando vosotros escribís un programa en C

576
00:36:25,289 --> 00:36:32,550
luego tenéis que hacer estos dos pasos, este otro, para que funcione este

577
00:36:32,550 --> 00:36:40,349
vuestro programa. Entonces vosotros tenéis el lenguaje básico, el lenguaje de alto nivel C,

578
00:36:40,349 --> 00:36:47,230
tenéis vuestro programa, llamáis uno programa que viene con la suite de programas para hacer

579
00:36:47,230 --> 00:36:53,090
funcionar C, es algo que no tenéis que crear vosotros, os lo dan bajándolo de internet desde

580
00:36:53,090 --> 00:37:01,250
algún sitio donde se desarrollan este tipo de cosas este programa aquí recibe vuestro

581
00:37:02,690 --> 00:37:11,329
código en c como input y lo que hace es compilarlo transformándolo en ceros y unos

582
00:37:12,889 --> 00:37:22,710
ahora cuando nosotros por ejemplo aquí utilizamos 30 este 30 nos descubriremos

583
00:37:22,710 --> 00:37:24,409
dentro de un dato, es una función

584
00:37:24,409 --> 00:37:26,469
¿vale? eso, ¿os acordáis

585
00:37:26,469 --> 00:37:28,769
estos bloques de programación estructurada

586
00:37:28,769 --> 00:37:30,769
que yo decía, calcular

587
00:37:30,769 --> 00:37:32,650
el triángulo, y dentro ponía

588
00:37:32,650 --> 00:37:34,750
como se ha calculado el triángulo, pues esta

589
00:37:34,750 --> 00:37:36,210
es la función, printf

590
00:37:36,210 --> 00:37:37,849
que lo que hace es recibir

591
00:37:37,849 --> 00:37:40,369
estas palabras

592
00:37:40,369 --> 00:37:42,590
como parámetro, y lo que

593
00:37:42,590 --> 00:37:44,309
hace es escribirlo en la pantalla

594
00:37:44,309 --> 00:37:46,989
ahora, ¿dónde está el código

595
00:37:46,989 --> 00:37:48,010
de esta printf?

596
00:37:49,230 --> 00:37:50,429
¿dónde está escrito

597
00:37:50,429 --> 00:37:53,469
los comandos que se tienen que ejecutar

598
00:37:53,469 --> 00:37:55,230
para que se imprima esto

599
00:37:55,230 --> 00:37:55,909
en pantalla

600
00:37:55,909 --> 00:37:58,010
aquí no está

601
00:37:58,010 --> 00:38:01,170
y yo no quiero

602
00:38:01,170 --> 00:38:02,869
cada vez que hago un programa

603
00:38:02,869 --> 00:38:04,730
básico que tiene que escribir

604
00:38:04,730 --> 00:38:06,570
hola mundo en pantalla

605
00:38:06,570 --> 00:38:08,829
tener que implementarme como

606
00:38:08,829 --> 00:38:10,969
se me interfazó, como lo leo

607
00:38:10,969 --> 00:38:12,670
desde la memoria, como voy a la

608
00:38:12,670 --> 00:38:14,869
pantalla, como pido al sistema

609
00:38:14,869 --> 00:38:16,710
operativo que escriba en pantalla, como va

610
00:38:16,710 --> 00:38:18,889
el sistema operativo al driver, todas estas cosas

611
00:38:18,889 --> 00:38:20,150
yo quiero que me las den ya hechas

612
00:38:20,150 --> 00:38:22,010
y me la dan ya hecha, es la print test

613
00:38:22,010 --> 00:38:23,789
no la he desarrollado yo

614
00:38:23,789 --> 00:38:26,630
está en una librería

615
00:38:26,630 --> 00:38:28,309
de funciones

616
00:38:28,309 --> 00:38:29,829
que C

617
00:38:29,829 --> 00:38:31,750
o Java o C++

618
00:38:31,750 --> 00:38:34,230
me dan a disposición y que yo puedo utilizar

619
00:38:34,230 --> 00:38:35,909
¿vale? ahora

620
00:38:35,909 --> 00:38:38,110
en la primera

621
00:38:38,110 --> 00:38:39,730
fase de compilación

622
00:38:39,730 --> 00:38:42,050
lo que se hace es pillar mi

623
00:38:42,050 --> 00:38:44,349
programa y transformarlos

624
00:38:44,349 --> 00:38:46,250
en ceros y unos, lo que he hecho yo

625
00:38:46,250 --> 00:38:48,030
pero claramente

626
00:38:48,030 --> 00:38:54,630
Y de allí habrá algunas funciones que yo he utilizado como la printrc que no he hecho.

627
00:38:54,630 --> 00:38:57,869
Entonces no la puede transformar en 081.

628
00:38:57,869 --> 00:39:03,650
Necesita lo que hemos dicho, estas librerías, este conjunto de datos que ya alguien más

629
00:39:03,650 --> 00:39:08,789
ha hecho y que no quiero hacer yo, donde estará escrito cómo funciona la printrc.

630
00:39:08,789 --> 00:39:12,050
Pues esto es aquí.

631
00:39:12,050 --> 00:39:15,369
Las librerías que usa mi programa.

632
00:39:15,369 --> 00:39:23,150
En la primera fase compilo mi programa y después enlazo aquellas funciones que mi programa

633
00:39:23,150 --> 00:39:30,389
usa que Perón no he hecho yo, que me ha dado ya a disposición el lenguaje de programación,

634
00:39:30,389 --> 00:39:34,730
por ejemplo C, que me da a disposición la Printerz.

635
00:39:34,730 --> 00:39:42,409
En la compilación se hacen dos pasos, compilo lo que tengo y le añado las funciones que

636
00:39:42,409 --> 00:39:45,170
he usado que Perón no son mías.

637
00:39:45,170 --> 00:39:52,769
enlazo las librerías que alguien más ha hecho para que complete los huecos que he dejado yo.

638
00:39:52,769 --> 00:39:57,469
Porque yo aquí sustancialmente he dicho, oye, escríbeme en pantalla esta cosa,

639
00:39:57,469 --> 00:40:01,670
pero no le he dicho cómo, entonces él dejará un hueco diciendo,

640
00:40:01,670 --> 00:40:05,809
pues luego ya aquí en este hueco pondré la implementación de esta printf.

641
00:40:05,809 --> 00:40:10,570
Alguien me dirá que la printf tiene que hacer estos comandos y yo los copiaré aquí.

642
00:40:10,570 --> 00:40:13,869
Esto se hace en la fase de enlazado

643
00:40:13,869 --> 00:40:15,369
¿Entiende?

644
00:40:16,889 --> 00:40:17,489
Entonces

645
00:40:17,489 --> 00:40:20,070
La compilación es esto

646
00:40:20,070 --> 00:40:22,050
Tengo mi lenguaje de alto nivel

647
00:40:22,050 --> 00:40:24,050
Compilo lo que puedo compilar

648
00:40:24,050 --> 00:40:24,989
Que he escrito yo

649
00:40:24,989 --> 00:40:27,869
Relleno las funciones

650
00:40:27,869 --> 00:40:30,030
De terceros que he utilizado

651
00:40:30,030 --> 00:40:30,670
En mi programa

652
00:40:30,670 --> 00:40:32,429
Y a este punto tengo

653
00:40:32,429 --> 00:40:35,329
Mi ejecutable

654
00:40:35,329 --> 00:40:37,510
Un programa de ceros y unos

655
00:40:37,510 --> 00:40:39,110
Que se puede ejecutar

656
00:40:39,110 --> 00:40:40,630
en un cierto Windows

657
00:40:40,630 --> 00:40:42,550
con un cierto procesador

658
00:40:42,550 --> 00:40:46,489
porque el lenguaje máquina

659
00:40:46,489 --> 00:40:48,650
depende de un procesador, depende del entorno

660
00:40:48,650 --> 00:40:50,789
donde lo ejecuto, no es lo mismo

661
00:40:50,789 --> 00:40:52,670
compilar para

662
00:40:52,670 --> 00:40:54,429
Windows que compilar

663
00:40:54,429 --> 00:40:56,269
para Macintosh

664
00:40:56,269 --> 00:40:58,250
que compilar para Linux

665
00:40:58,250 --> 00:41:00,489
o para

666
00:41:00,489 --> 00:41:01,889
AMD que para Intel

667
00:41:01,889 --> 00:41:04,610
por eso que, porque no se puede

668
00:41:04,610 --> 00:41:06,469
ahora ya vamos más, pero porque no se

669
00:41:06,469 --> 00:41:08,030
todos los juegos que hay en PC

670
00:41:08,030 --> 00:41:09,929
no se pueden jugar en

671
00:41:09,929 --> 00:41:11,510
en Apple, en Mac

672
00:41:11,510 --> 00:41:14,369
porque no están compilados

673
00:41:14,369 --> 00:41:15,750
¿vale?

674
00:41:16,969 --> 00:41:18,090
y compilar

675
00:41:18,090 --> 00:41:19,789
en otro sistema puede dar problemas

676
00:41:19,789 --> 00:41:21,750
y no hay inversión suficiente

677
00:41:21,750 --> 00:41:23,809
para decir no lo quiero compilar

678
00:41:23,809 --> 00:41:25,889
también para la otra cosa ¿vale? porque no hay

679
00:41:25,889 --> 00:41:27,909
juegos en Linux o hay muy pocos juegos

680
00:41:27,909 --> 00:41:29,869
en Linux porque la gente, la mayoría

681
00:41:29,869 --> 00:41:31,809
tiene Windows en casa y

682
00:41:31,809 --> 00:41:33,590
tener el esfuerzo de hacer

683
00:41:33,590 --> 00:41:35,610
compilaciones que funcionan y

684
00:41:35,610 --> 00:41:37,969
debugging, o sea, quitar los errores

685
00:41:37,969 --> 00:41:39,690
también en Linux para

686
00:41:39,690 --> 00:41:42,030
los 3% de usuarios

687
00:41:42,030 --> 00:41:43,730
que tienen Linux y que juegan

688
00:41:43,730 --> 00:41:45,510
en Linux, pues no compensa.

689
00:41:47,849 --> 00:41:50,980
¿Entiendes? Pues

690
00:41:50,980 --> 00:41:51,980
esta es la compilación.

691
00:41:53,579 --> 00:41:54,260
Entonces,

692
00:41:54,940 --> 00:41:56,440
en la primera fase,

693
00:41:57,000 --> 00:41:58,679
se pilla el programa fuente,

694
00:41:58,840 --> 00:42:00,820
lo que he escrito yo en código, y se

695
00:42:00,820 --> 00:42:02,559
transforma en un programa objeto

696
00:42:02,559 --> 00:42:03,980
que es como

697
00:42:03,980 --> 00:42:05,159
una

698
00:42:05,159 --> 00:42:08,900
nueva versión del mismo

699
00:42:08,900 --> 00:42:11,280
programa, pero escrito en otro lenguaje.

700
00:42:11,460 --> 00:42:12,500
Esto está escrito en C,

701
00:42:12,500 --> 00:42:14,639
esto está escrito en

702
00:42:14,639 --> 00:42:16,260
lenguaje mágico

703
00:42:16,260 --> 00:42:18,920
y después

704
00:42:18,920 --> 00:42:20,800
con el código objeto

705
00:42:20,800 --> 00:42:22,980
y las librerías que son

706
00:42:22,980 --> 00:42:24,860
toda esta información adicional

707
00:42:24,860 --> 00:42:26,840
que viene cuando yo programo en C

708
00:42:26,840 --> 00:42:29,219
me instalo el kit para programar

709
00:42:29,219 --> 00:42:30,880
en C o cuando por ejemplo

710
00:42:30,880 --> 00:42:32,619
trabajo en Java, me instalaré

711
00:42:32,619 --> 00:42:35,000
el JDK, el Java Development Kit

712
00:42:35,000 --> 00:42:37,239
¿vale? aun si Java es un poquito distinto

713
00:42:37,239 --> 00:42:37,960
ya lo veremos

714
00:42:37,960 --> 00:42:40,860
pues sumando estas dos cosas

715
00:42:40,860 --> 00:42:46,539
obtengo mi programa ejecutado este de aquí ya lo puedo llevar a mi ordenador a hacer doble clic y

716
00:42:46,539 --> 00:42:52,500
se ejecutará y funcionará mi programa si lo lleva a otro ordenador con características similares

717
00:42:52,500 --> 00:42:58,980
también me funciona lo llevo un ordenador con otro sistema operativo o con otro hardware

718
00:42:58,980 --> 00:43:10,840
completamente el posible entre los dobles que no me funciona si dudas el intérprete

719
00:43:10,840 --> 00:43:19,119
vez analiza el programa fuente y lo ejecuta directamente. Va línea por línea. Facilita

720
00:43:19,119 --> 00:43:24,500
la búsqueda de errores ya que un programa puede interrumpirse en cada momento. Una cosa

721
00:43:24,500 --> 00:43:30,019
interesante del intérprete es que yo digo ejecútame esto, vale, ejecútame esto, vale, ejecútame esto y ahora

722
00:43:30,019 --> 00:43:36,000
cuando llegas aquí déjame ver qué está pasando. Como él ejecuta de uno en uno pues es mucho más

723
00:43:36,000 --> 00:43:40,820
fácil. En un compilador no, porque el compilador ya está todo compilado y ejecuta de golpe.

724
00:43:40,820 --> 00:43:48,300
Se puede modificar sobre la marcha. Hay intérprete que me permite, mira esto está

725
00:43:48,300 --> 00:43:53,179
funcionando mal, espera un momento, cambio el código y como él va interpretando de uno en uno,

726
00:43:53,179 --> 00:44:00,099
pues al añadirle un código adentro o en un bucle cambiándole algo, pues la siguiente vez que pasa

727
00:44:00,099 --> 00:44:05,880
por allí, pues ejecutará una cosa distinta. Y es menos eficiente porque es un programa compilado.

728
00:44:05,880 --> 00:44:08,679
porque claro, si yo compilo

729
00:44:08,679 --> 00:44:10,880
ya tengo todo hecho, es solo ejecutar

730
00:44:10,880 --> 00:44:12,900
lo que está allí, puedo ir del tirón rápido

731
00:44:12,900 --> 00:44:14,719
esto por cada línea

732
00:44:14,719 --> 00:44:16,659
de programa tendrá que hacer una serie

733
00:44:16,659 --> 00:44:17,960
de ejecuciones que son

734
00:44:17,960 --> 00:44:20,519
voy a mirar que quieres hacer

735
00:44:20,519 --> 00:44:22,579
lo voy a traducir en lenguaje máquina

736
00:44:22,579 --> 00:44:24,840
lo ejecuto, vale, ahora otro

737
00:44:24,840 --> 00:44:29,309
son pasos más lejos

738
00:44:29,309 --> 00:44:32,550
aquí está la comparación

739
00:44:32,550 --> 00:44:34,570
entre compilador e intérprete

740
00:44:34,570 --> 00:44:36,949
que veremos mañana