Saltar navegación

T0 - Introducción - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 16 de septiembre de 2024 por Raquel G.

68 visualizaciones

Más información Transcripción

Descargar la transcripción

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. 00:00:01
pero es que resulta que alguien 00:00:26
decidió hace un montón 00:00:29
de años, un montón de años 00:00:31
mucho antes de que yo naciera incluso 00:00:33
o mucho, mucho, mucho 00:00:34
descubrió en los tiempos de antes 00:00:36
no en los de ahora, que son mucho mejores 00:00:39
faltaría más 00:00:41
pues de repente un tío 00:00:42
que al pobre le trataron muy mal además 00:00:44
¿qué? 00:00:47
claro que lo habéis dado, en sistemas 00:00:51
pues un tío muy listo 00:00:53
dijo 00:00:55
jolines, tenemos una arquitectura 00:00:56
que nos permite resolver de forma automática 00:00:59
algunos problemas, no todos 00:01:03
pero algunos sí, y esa arquitectura 00:01:05
de Von Neumann, los que habéis 00:01:08
estudiado el ciclo de sistemas 00:01:10
pues os la conocéis de memoria, nosotros vamos a simplificar 00:01:13
muy por encima, no vamos a detenernos en ello 00:01:17
¿pero en qué consiste? 00:01:20
pues tenemos una cosa que se llama CPU 00:01:24
que tiene unos registros 00:01:26
dentro, unos cuantos registros 00:01:30
para meter datos 00:01:32
y además tiene una cosa estupenda 00:01:33
que es una unidad 00:01:36
aritmético-lógica 00:01:38
que ¿qué sabe hacer? sumas, restas 00:01:39
chorraditas, sumas y restas 00:01:42
y poquito más 00:01:44
y además tiene una unidad de control 00:01:44
¿para qué sirve esta unidad de control? 00:01:50
para dar órdenes 00:01:55
a que se muevan datos por ahí, 00:01:56
porque esta unidad aritmético-lógica 00:01:59
es capaz de sumar y restar 00:02:01
cositas que hay en esos registros de dentro. 00:02:03
Vale, pero de esos registros de dentro, 00:02:06
¿de dónde le llega la información? 00:02:09
Hombre, pues vamos a añadir 00:02:10
la arquitectura de Von Neumann esta, 00:02:12
una memoria RAM con datos. 00:02:15
Entonces, ¿cómo pasan los datos de la memoria RAM 00:02:18
a los registros de la CPU 00:02:22
para que la unidad aritmético-lógica 00:02:24
sea capaz de sumarlos 00:02:26
restarlos o lo que haga falta 00:02:28
vamos a poner unos cablecitos 00:02:30
pues venga, ponemos unos cablecitos por ahí 00:02:31
que son los buses 00:02:34
un montón de cablecitos 00:02:36
estos buses pues tienen acceso 00:02:38
desde ellos la RAM 00:02:40
tiene acceso la CPU 00:02:42
y no solo eso, también tiene acceso 00:02:43
unas unidades 00:02:46
de entrada y salida 00:02:48
que hay por ahí que a mí me nos importan menos 00:02:49
por si alguien desde 00:02:52
fuera, el que no está físicamente 00:02:54
metido ahí viviendo en la tarjeta 00:02:56
en la placa, en la placa base 00:02:59
para el que no está metido en la placa base 00:03:00
que está fuera, si quiere ver lo que pasa 00:03:02
adentro, pues hombre, ese está 00:03:04
aquí, no está metido dentro 00:03:06
de la placa base, entonces ese 00:03:08
mira aquí y ve lo que 00:03:10
hay dentro, entonces esta 00:03:12
unidades de entrada y salida, pues también 00:03:14
se conectan a los buses para 00:03:16
sacar lo que hay dentro y mostrárselo 00:03:18
en una pantalla, en una impresora 00:03:20
en donde sea 00:03:22
vale, esto es la arquitectura 00:03:23
de Von Neumann, ya está, ¿y en qué consiste 00:03:26
esto? pues consiste 00:03:28
en esta memoria RAM 00:03:29
hay un cachito 00:03:32
una porción 00:03:34
que tiene una cosa 00:03:36
que se llama programa 00:03:37
¿y qué es una cosa que se llama programa? 00:03:39
una cosa que se llama programa 00:03:45
es una secuencia de instrucciones 00:03:46
de órdenes, de cosas que hay que hacer 00:03:48
pa pa pa pa pa 00:03:50
pues aquí están, en la memoria RAM 00:03:52
vale, ese programa 00:03:55
para que haga algo interesante 00:03:57
tiene que trabajar con datos 00:03:58
suma esto, resta esto, haz esto 00:03:59
¿esos datos dónde están? pues también aquí 00:04:02
aquí hay otro trocito de la RAM 00:04:04
que tiene datos 00:04:06
vale, pues el ordenador arranca 00:04:08
pum, encendemos el ordenador 00:04:12
vale, pues entonces 00:04:13
arranca ciertas cosas, se encienden lucecitas 00:04:15
patatín patatán, se lee una memoria 00:04:18
se lee una memoria que está 00:04:20
ahí pequeñita, que no se borra nunca 00:04:22
para hacer unas primeras inicializaciones 00:04:24
etcétera, etcétera, y ahora ya empieza 00:04:26
el funcionamiento general 00:04:28
del equipo, ¿y cuál es? 00:04:29
pues que la unidad 00:04:32
de control va dando órdenes 00:04:33
una tras otra, pa, pa, pa 00:04:35
para que a través del bus vayan pasando 00:04:37
una tras otra estas instrucciones 00:04:39
una aquí dentro, un registro 00:04:41
interprétala 00:04:43
y lo que haga 00:04:45
y que la unidad aritmético 00:04:47
lógica ejecute lo que te dice 00:04:50
esta sentencia 00:04:51
la unidad aritmético lógica lo ejecuta 00:04:52
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. 00:04:56
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. 00:05:05
sentencia, aquí 00:05:24
al registro de instrucción 00:05:26
que se llama, el que tiene la sentencia 00:05:28
registro de instrucción, ahora 00:05:30
aquí hay una serie de circuitos 00:05:32
lógicos extraños, condensadores, transistores 00:05:34
cosas raras, que decodifican 00:05:36
esa sentencia 00:05:39
para que la unidad aritmético-lógica 00:05:39
haga las sumas, restas o lo que haga falta 00:05:42
como consecuencia de esas sumas 00:05:44
restas, aquí aparecen datos 00:05:46
en los registros de la CPU 00:05:48
y esos datos, wow 00:05:50
vuelven hacia la rama 00:05:52
a través de los bus, vuelven aquí 00:05:53
a la siguiente, siguiente sentencia 00:05:56
muy bien, siguiente sentencia, el registro de instrucción 00:05:58
los circuitillos que hay por aquí 00:06:00
la decodifican 00:06:02
como consecuencia de decodificar 00:06:04
de decodificarla, esta hace su suma 00:06:06
y sus restas, los resultados 00:06:08
vuelven aquí 00:06:10
y así todo el rato, así todo el rato 00:06:12
y eso es lo que hace un ordenador 00:06:14
todo el rato, ya está 00:06:16
el propio sistema operativo que es 00:06:17
un programa que está aquí cargado 00:06:19
el sistema operativo inicialmente 00:06:21
está en el disco duro 00:06:23
por supuesto, ahí está el sistema operativo 00:06:26
pero cuando el ordenador 00:06:28
se arranca, en el disco duro 00:06:30
no pinta nada eso ahí 00:06:32
¿qué es lo que se hace automáticamente? 00:06:33
todo el programa o parte del sistema operativo 00:06:36
pam, a la RAM 00:06:38
ahí se queda 00:06:40
y a partir de ahí ya empieza 00:06:41
primera secuencia del sistema operativo 00:06:43
aquí, la decodifico y la hago 00:06:46
segunda, tercera 00:06:48
que ahora el sistema operativo 00:06:49
llama a otro programa 00:06:51
porque yo he dado a un clic 00:06:53
pues entonces 00:06:54
la instrucción de ese programa es la que pasa 00:06:56
aquí y así todo el rato 00:06:59
y eso todo el rato es lo que está haciendo 00:07:00
todo el rato 00:07:01
pues esta es muy en resumen 00:07:03
la arquitectura de Von Neumann 00:07:07
y esto es 00:07:08
lo que tenéis en una placa base 00:07:10
cuando la abrís, ya está 00:07:13
todo esto, pues la tarjeta gráfica 00:07:14
los buses, la RAM 00:07:17
el microprocesador 00:07:19
pues en resumen eso es lo que tenéis en una placa base 00:07:20
cuando lo hacéis todo eso 00:07:23
bueno entonces como veis 00:07:24
los programas 00:07:27
son una cosa muy fea 00:07:29
y muy difícil de entender y muy complicada 00:07:31
de hacer porque que hay 00:07:33
en una memoria RAM 00:07:35
ceros y unos 00:07:36
eso es lo único que hay 00:07:38
ceros y unos porque eso es lo único 00:07:40
que un ordenador puede almacenar 00:07:43
dentro y lo único 00:07:45
que una unidad aritmético lógica 00:07:47
o una CPU puede entender. 00:07:49
Lo único. 00:07:51
Luego un programa son un montón de 00:07:53
ceros y unos 00:07:56
que significan cosas. 00:07:57
¿Y qué significan? 00:08:00
Hostia, bueno, tendría que aprender. 00:08:02
Estos ceros y unos 00:08:04
significan esto, estos ceros y unos significan esto. 00:08:05
Claro, ¿alguien puede hacer eso? 00:08:08
Es absolutamente imposible. 00:08:10
Con lo cual no se programa 00:08:11
directamente poniendo ceros y unos. 00:08:13
¿Vale? 00:08:16
Este es el lenguaje máquina. 00:08:17
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? 00:08:19
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? 00:08:37
¿Vale? Esa nomenclatura, aunque solo sea de bachillerato la ESO, sonará, ¿no? 00:08:48
Cada uno de esos es un bit, que normalmente están agrupados como mínimo de 8 en 8, que es un byte. 00:08:53
Bueno, pues un programa directamente escrito ya en bits, en 0s y 1s, y cargado en RAM, 00:08:59
que es lo único que puede tener la RAM, es un programa en lenguaje máquina. 00:09:03
¿Qué ocurre? Que así no podemos darle órdenes a la CPU, es imposible, nadie puede programar en 0s y 1s. 00:09:07
Vale, pues entonces, se hizo un primer salto. 00:09:14
Hablo del origen de esos tiempos de antes. 00:09:18
Digo, como los ceros no son muy complicados, vamos a hacer un primer salto, 00:09:21
que es el lenguaje ensamblador. 00:09:26
Vale, pues el lenguaje ensamblador es un lenguaje de programación, 00:09:37
ya es algo que uno puede escribir con letras y números, con algo que le suena, 00:09:41
porque los ceros y números no suenan. 00:09:45
el lenguaje ensamblador ya es algo que uno escribe con letras 00:09:46
con cosas que suenan 00:09:49
y escribe ahí sus órdenes el lenguaje ensamblador 00:09:51
pero es muy raro 00:09:53
porque son órdenes muy muy muy básicas 00:09:55
el lenguaje ensamblador 00:09:58
es el lenguaje que le da 00:09:59
todo completamente 00:10:02
triturado, desglosado 00:10:03
y machacado a la unidad aritmético-lógica 00:10:05
suma esto con esto 00:10:07
mueve esto a este registro 00:10:09
ahora suma esto con esto, mueve esto a este otro registro 00:10:11
madre mía 00:10:14
hacer cualquier cosa en lenguaje ensamblador 00:10:15
directamente, son 00:10:17
tropecientes líneas de lenguaje 00:10:19
lo que pasa es que una vez que está 00:10:20
en lenguaje ensamblador, traducirlo 00:10:23
al lenguaje máquina 00:10:25
es muy fácil 00:10:26
hay un pequeño software, ya directamente 00:10:28
te lleva, te lo traduce 00:10:32
a ceros y unos, muy rápido 00:10:33
e inmediato, porque casi 00:10:35
cada sentencia de lenguaje ensamblador 00:10:37
casi cada una de ellas es un byte 00:10:39
es un lenguaje tan básico, que te lo da todo 00:10:41
tan, tan, tan, tan machacado 00:10:43
Y el lenguaje ensamblador se ha programado muchísimo, para que veáis la pinta que tiene el lenguaje ensamblador. 00:10:45
Por ejemplo, si vamos a ver un explorador y poner cualquier ejemplo de código ensamblador, vale, 00:10:52
ah no, que esto es un vídeo, yo quiero una imagen, imágenes, vale, pues, es que ni siquiera se, 00:11:17
bueno, no he cogido una imagen que se vea muy bien 00:11:36
bueno, y aparte es bastante complicado 00:11:39
verlo 00:11:41
vale, pues el lenguaje ensamblador ya es algo que uno puede 00:11:41
escribir en realidad, lo escribe en su blog 00:12:03
de notas donde haga falta 00:12:05
y es algo que tiene un aspecto 00:12:06
como esto 00:12:09
a ver si sale bien 00:12:10
vale, como veis 00:12:12
son 00:12:22
términos muy extraños 00:12:24
letras muy raras 00:12:26
veis, aquí veis atcu 00:12:28
esto significa suma 00:12:30
suma lo que hay en este registro 00:12:32
a este otro registro 00:12:34
son sentencias muy básicas 00:12:36
cualquier algoritmo 00:12:38
con ponerlo en ensamblador 00:12:40
son un montón de sentencias 00:12:41
pero tienes que dar muy desglosado 00:12:43
entonces, estos son comentarios 00:12:44
veis aquí 00:12:48
con esto está haciendo un error exclusivo 00:12:49
a los que vengáis de sistemas o suene de la ESO 00:12:51
de bachillerato, un error exclusivo 00:12:54
de estos dos registros 00:12:56
aquí una comparación 00:12:57
son sentencias en realidad, ya se entienden 00:12:59
add, compare 00:13:03
esto ya es un lenguaje 00:13:04
de programación, ya se puede programar en él 00:13:07
pero sigue siendo 00:13:08
un poco locura 00:13:10
hacer una aplicación en ensamblador es una locura 00:13:11
pero claro, ¿cuál es la ventaja? 00:13:14
que si uno hace un programa en ensamblador 00:13:17
tiene el control absoluto 00:13:19
de todo lo que está haciendo su CPU 00:13:21
de todo, porque es que 00:13:23
le está dando paso a paso lo que tiene que hacer 00:13:24
no tiene ningún margen 00:13:26
de maniobra 00:13:28
vale, pero 00:13:29
por ejemplo, en aplicaciones 00:13:35
en aplicaciones en las cuales 00:13:38
uno tiene 00:13:40
un sistema de control controlado por una 00:13:42
CPU y es fundamental 00:13:44
pues que funcione, está controlando 00:13:46
una cinta de embalaje 00:13:50
yo que sé, una cinta industrial, cualquier cosa 00:13:52
y ahí es crítico que el funcionamiento 00:13:54
no falle, los tiempos 00:13:56
todo, pues esa CPU 00:13:58
que controla a lo mejor esa línea de montaje 00:13:59
pues ahí lo ideal directamente 00:14:02
es programarla en su lenguaje ensamblador 00:14:04
entonces controlas exactamente lo que está en esa CPU 00:14:06
pero claro, una aplicación 00:14:08
de mi tienda de 00:14:10
de ositos de peluche 00:14:12
pues no la voy a programar en ensamblador 00:14:14
o mi tienda de ositos de peluche, pues tampoco es tan crítico 00:14:15
que la CPU sume los peluches como dé la gana 00:14:18
da igual, ¿vale? 00:14:20
entonces, no programamos en ensamblador 00:14:22
siguiente salto 00:14:24
Siguiente salto 00:14:26
Como 00:14:38
Vale, entonces como somos muy vagos 00:14:40
Para programar en el ensamblador 00:14:44
Aparte, no solo el problema de la baguería 00:14:45
Ya natural 00:14:48
Sino que programar en el ensamblador implica 00:14:49
Que tú tienes que programar para una CPU en concreto 00:14:52
Hombre, eso no nos gusta 00:14:54
Nos gustan programas que me valgan 00:14:56
Para cualquier ordenador 00:14:57
Bueno, pues por esos problemas 00:14:59
Por lo prácticamente imposible 00:15:01
Que es programar en el ensamblador 00:15:03
y porque yo quiero ser multiplataforma, no solo para una CPU, 00:15:05
pues se dio, o damos, el siguiente salto, que es ya el código fuente. 00:15:11
Bueno, lenguajes de alto nivel, llamémosle lenguajes de alto nivel. 00:15:22
Vale, pues los lenguajes de alto nivel están ya por encima del ensamblador. 00:15:26
De hecho, ya que habías mencionado el C, el lenguaje C, por ejemplo, 00:15:39
siempre se ha dicho que es un lenguaje intermedio, 00:15:43
porque tiene mucha capacidad de tocar 00:15:46
a nivel de CPU 00:15:48
pero no es el ensamblador, afortunadamente 00:15:49
y también tiene 00:15:52
las estructuras y las ventajas de los lenguajes 00:15:54
de alto nivel, entonces el C 00:15:56
es un lenguaje, siempre se ha dicho 00:15:58
que intermedio, por eso es un lenguaje que se ha usado mucho 00:16:00
para programar sistemas operativos 00:16:02
por ejemplo, como Linux, etc 00:16:04
vale, pero 00:16:06
normalmente programamos en lenguajes de 00:16:08
más alto nivel, entre comillas 00:16:10
el alto nivel no es porque sean mejores, de hecho 00:16:12
no, siempre sería mejor esto 00:16:14
El alto nivel es porque me abstraen de un montón de problemas que hay debajo y yo programo como si fuera tonto. 00:16:16
Le doy unas instrucciones muy genéricas, lee del teclado y yo pongo lee del teclado directamente en mi sentencia 00:16:26
y ya cuando se traduce eso a código máquina, una única sentencia de alto nivel, lee del teclado, 00:16:35
pues a lo mejor se traduce en mil 00:16:44
de código máquina. Y yo esa traducción 00:16:45
no la hago. Ya veremos cómo se automatiza. 00:16:48
No la hago. Yo me limito a poner 00:16:50
mi código de lenguaje de alto nivel. 00:16:51
Lee del teclado 00:16:54
y punto pelota. Y ya eso se traduce 00:16:55
a mil ceros y unos. 00:16:57
¿Cuál es el problema? Que la traducción 00:17:00
la hacemos nosotros, perdemos el control. 00:17:02
A lo mejor la traducción no es óptima. 00:17:04
Y si la hago yo 00:17:07
a mano, poniendo mis ceros y unos, la lectura 00:17:08
del teclado es magnífica. Pero la que ha hecho 00:17:09
él, pues a lo mejor hace unos 00:17:12
trasbases innecesarios, entonces no 00:17:13
controlamos tanto. Pero es que a veces 00:17:15
es inevitable. Si no programamos con lenguaje de alto nivel 00:17:17
es que no avanzamos. 00:17:19
Aunque haya una parte que no controlemos, que es la 00:17:21
traducción a esta. 00:17:23
Bueno, pues entonces nuestro caso, 00:17:25
el caso general, en el mundo comercial 00:17:27
es el caso de usar 00:17:29
lenguajes de alto nivel. 00:17:31
Y lenguajes de alto nivel, pues ya os suenan 00:17:35
todos. Lenguajes de alto nivel 00:17:37
os suena todo, pues os suena Python, 00:17:40
claro, os suena Java, 00:17:42
Os suena a cesar, que son de los tres más usados 00:17:44
Y hay tropecientos mil más 00:17:48
Lenguajes de alto nivel 00:17:49
Y todos son lo mismo 00:17:51
Esencialmente 00:17:53
C++, que aunque está más antiguo que cesar 00:17:54
Todos son lo mismo 00:17:58
Un montón de sentencias 00:18:00
Que uno escribe en un fichero de texto 00:18:03
Y esas sentencias 00:18:06
De alguna manera mágica 00:18:09
O no mágica 00:18:11
Alguien las traduce a esto 00:18:12
los cero signos, que esto es lo válido, ¿vale? 00:18:15
Bueno, pues entonces, los lenguajes de alto nivel, repito, 00:18:19
se basan en la escritura de un código fuente, ¿vale? 00:18:22
¿Qué es mi código fuente? 00:18:32
Un montón de sentencias, una tras otra, 00:18:34
escritas en el lenguaje correspondiente, ¿vale? 00:18:39
A ver, ¿vale? ¿El código fuente qué es? 00:18:47
Es un fichero de texto, 00:19:00
fichero de texto 00:19:02
es decir, un fichero que tiene 00:19:05
código ASCII, texto, letritas 00:19:09
que uno pone en el blog de notas, donde sea 00:19:11
no en el Word, porque el Word no es un editor 00:19:13
de texto, el Word es otra cosa 00:19:15
que escribe sus caracteres extraños 00:19:17
el código fuente es un fichero 00:19:19
que tiene exclusivamente 00:19:21
caracteres ASCII, texto, nada más 00:19:23
no tiene caracteres de control del Word 00:19:25
no tiene formato, no tiene nada 00:19:27
bueno, pues el código fuente es un fichero 00:19:29
de texto exclusivamente 00:19:31
caracteres ASCII 00:19:33
que contiene 00:19:35
una secuencia de sentencias 00:19:37
escrita en el lenguaje correspondiente 00:19:41
según las reglas del lenguaje, claro 00:19:52
¿vale? según las reglas 00:19:54
de un lenguaje de 00:20:03
programación, ese es el 00:20:05
código, el fichero de texto que contiene 00:20:10
la secuencia de sentencias escrita 00:20:11
según las reglas que me diga 00:20:13
el lenguaje de programación, ¿vale? 00:20:15
claro, el problema es cómo construyo 00:20:17
su fichero, pero bueno, ya estamos con 00:20:19
el contexto de la operación. 00:20:23
Vale, este código fuente, este fichero, 00:20:26
¿a lo largo le vale para algo? 00:20:29
Para nada, esto no vale para nada. 00:20:31
Esto es un fichero de texto que tiene carácter exástico. 00:20:33
¿La CPU qué va a hacer con eso? 00:20:36
¿Qué es la que ejecuta las cosas? 00:20:38
La CPU no va a hacer nada. 00:20:39
Recordad que la CPU lo que necesita 00:20:41
es en una RAM un montón de ceros y unos 00:20:43
para luego ya interpretarlas 00:20:47
aquí 00:20:51
¿vale? 00:20:51
entonces, el fichero de texto no vale 00:20:57
para nada, yo lo tengo ahí en mi escritorio 00:20:58
donde se, no vale para nada 00:21:00
entonces, para que esto se ejecute 00:21:01
la CPU sea capaz de ejecutarlo 00:21:04
tenemos que transformarlo 00:21:06
a código máquina 00:21:08
¿vale? entonces, código 00:21:11
fuente, el fichero de texto con la 00:21:14
secuencia de caracteres 00:21:16
según el lenguaje de programación 00:21:18
código máquina 00:21:21
los ceros y unos que van a la RAM 00:21:25
que son el resultado de traducir 00:21:28
esto de aquí y que ya se ejecutan en la RAM 00:21:30
aquí estaría el código máquina 00:21:32
bueno, pues 00:21:34
¿cómo se hace esta traducción? 00:21:42
hay 00:21:45
varios modelos distintos de hacerlo 00:21:45
pero son tres en general 00:21:48
tres en general 00:21:50
vamos a ver, traducción de código fuente a código máquina 00:21:51
problema fundamental, claro 00:21:54
vale, tenemos 00:21:57
nuestro código fuente 00:22:06
y tenemos que pasarlo a código 00:22:08
máquina, cuando ya lo hayamos 00:22:16
pasado a código máquina ya podremos hacer el click 00:22:22
para ejecutarlo, claro que ya se podrá 00:22:24
cargar en la rama, etcétera 00:22:26
vale, ¿cómo? ¿cómo se puede hacer esto? 00:22:28
bueno, pues hay tres 00:22:31
filosofías, digamos distintas 00:22:32
una es 00:22:34
la compilación 00:22:36
Otra es la interpretación 00:22:37
Y otra es la intermedia 00:22:44
Ni una ni otra, un poquito de las dos 00:22:52
¿Vale? 00:22:54
Serían las tres filosofías 00:23:05
De pasar de un código fuente 00:23:06
A la ejecución ya de un código mágico 00:23:09
La tradicional 00:23:12
Ha venido siendo siempre 00:23:14
La compilación 00:23:17
¿En qué consiste el proceso de compilación? 00:23:19
Bueno 00:23:25
Consiste simplemente en que existe 00:23:26
un software que se llama 00:23:29
software compilador 00:23:30
que afortunadamente no lo hace el que desarrolla 00:23:31
el programa, nuestro problema es hacer el código fuente 00:23:34
y ya está, bueno pues hay un 00:23:36
software compilador 00:23:38
que traduce y ya está 00:23:39
tú a ese compilador le dices 00:23:45
compila este código fuente 00:23:52
prueba, no sabemos como lo hace 00:23:54
y ya está, ya tiene el código máquina 00:23:56
y te saca un fichero en código máquina 00:23:59
tú le das un fichero en código fuente 00:24:02
y te devuelve como resultado 00:24:04
un fichero en código máquina 00:24:06
que es lo que solemos llamar 00:24:08
el ejecutable 00:24:10
ese software compilador 00:24:11
lo habrá desarrollado 00:24:16
el que desarrolló 00:24:18
el lenguaje de alguna manera 00:24:21
eso es lo natural 00:24:22
un poco lo que se ha hecho siempre 00:24:26
pero claro, era lo natural 00:24:28
sobre todo 00:24:31
cuando los programas eran más pequeños 00:24:32
hacían cosas más atómicas 00:24:35
entonces tú tienes un programa 00:24:36
lo compilabas y ya tienes el ejecutable 00:24:37
y ya está 00:24:39
y hacía siempre lo mismo 00:24:41
entonces cuando había, cuando la tarea de programación 00:24:42
estaba como más acotada 00:24:45
hacías cositas pequeñas y más 00:24:46
ahora ya con todo distribuido 00:24:48
con aplicaciones distribuidas por internet 00:24:50
con una aplicación web que para que se ejecute aquí 00:24:52
para que se ejecute aquí 00:24:54
ahora ya lo de compilo y tengo mi ejecutable 00:24:55
y me llevo una CPU a ejecutar 00:24:58
es un modelo que se ha quedado un poco rígido 00:25:00
¿vale? se ha quedado un poquito rígido 00:25:02
pero no deja de ser en realidad 00:25:04
el mejor 00:25:07
porque conduce a ejecuciones más rápidas 00:25:09
tu programa ya está compilado en código máquina 00:25:11
ejecutarlo, pipí, es súper rápido 00:25:14
ala, la CPU va a leer 00:25:16
los bits, ya está 00:25:18
es lo más rápido 00:25:19
a la hora de ejecutarlo 00:25:22
da programas de rápida ejecución 00:25:23
pero es poco flexible 00:25:25
entonces 00:25:27
¿en qué se basa la interpretación? 00:25:30
la interpretación 00:25:33
se basa en que un intérprete 00:25:35
otro software 00:25:36
que se llama software intérprete 00:25:38
va leyendo línea por línea del código fuente 00:25:40
y va ejecutando, y va traduciendo y ejecutando. 00:25:47
Es el tiempo real, no tienes que estar... 00:26:13
Exacto. 00:26:15
No hay un ejecutable como tal. 00:26:16
Tú directamente, el código fuente es el que ejecutas. 00:26:18
No es que el código fuente se ejecuta, 00:26:21
lo que haces es llamar al intérprete y él va, 00:26:23
sentencia, la traduzco y ejecuto. 00:26:26
Sentencia, la traduzco y ejecuto. 00:26:28
Entonces, desventaja, 00:26:31
que estas ejecuciones son mucho más lentas, 00:26:33
porque cada ejecución implica una traducción 00:26:35
cada vez que ejecutas 00:26:38
traduzco y ejecuto 00:26:39
claro, estás compilando 00:26:41
una por una todo el rato 00:26:46
entonces son programas 00:26:47
más lentos, son lenguajes de traducción más lentos 00:26:50
pero es mucho más flexible 00:26:52
porque puedes parar en cualquier 00:26:53
momento la ejecución 00:26:56
incluso puedes 00:26:57
ejecutar 00:27:00
multiplataforma, pero como estás ejecutando 00:27:02
por trocitos, entonces es más flexible. 00:27:03
Admite más 00:27:06
plataformas distintas, pero es más lento. 00:27:07
Entonces, 00:27:11
interpretados puros, 00:27:12
pues es Python, por ejemplo. 00:27:14
Python es interpretado puro, ya, así no se complica la vida. 00:27:15
¿Vale? Bueno, 00:27:18
entonces, ¿cuál es el intermedio? El que intenta 00:27:22
no ser 00:27:24
tan lento como este, 00:27:26
pero no ser tan rígido 00:27:28
como este, aunar las dos cosas. 00:27:30
Pues la filosofía intermedia, 00:27:33
que es la de Java, por ejemplo. 00:27:35
vale, esta es la filosofía 00:27:36
de Java, entonces partimos siempre de un código fuente 00:27:51
eso está claro 00:27:53
nosotros tenemos 00:27:54
nuestro código fuente de Java 00:27:56
que nuestro código fuente, recordad 00:27:59
que es un fichero de texto, una secuencia de caracteres 00:28:05
que en concreto ya podemos 00:28:07
avanzar, que ese 00:28:09
fichero de texto se recoge en un archivo 00:28:11
pues de extensión .java 00:28:13
siempre 00:28:15
el nombrecito que sea 00:28:15
con la extensión .java 00:28:18
ese es mi fichero de texto 00:28:20
escrito en el blog de notas o donde me dé la gana 00:28:22
vale 00:28:24
ahora 00:28:25
hay una especie de pre-compilador 00:28:26
pre-compilación 00:28:30
pre-compilación 00:28:32
que nos genera un ejecutable 00:28:39
genera una versión intermedia 00:28:40
pensada para que se pueda 00:28:43
ejecutar en cualquier plataforma 00:28:45
pensada para 00:28:47
simplemente particularizando para la plataforma 00:28:48
eso es una versión todavía no ejecutable 00:28:51
pero que ya tiene mucha parte compilada 00:28:54
y ha dejado sin compilar 00:28:57
lo que depende de la 00:28:59
plataforma concreta simplemente 00:29:00
entonces, se hace una primera 00:29:02
pre-compilación 00:29:04
esta pre-compilación, ya iremos viendo 00:29:06
genera unos ficheros 00:29:08
con extensión .class 00:29:10
es lo que genera, unos ficheros con extensión .class 00:29:12
estos, repito, no son ejecutables 00:29:14
todavía, pero tienen ya 00:29:16
mucho código máquina metido, estos ya son 00:29:18
bits, pero no son bits que 00:29:20
podemos poner en la RAM. 00:29:22
Entonces, ¿ahora quién entra 00:29:25
en juego? Cuando ya queremos ejecutar 00:29:26
este, lo que hacemos es llamar 00:29:28
a la Java Virtual 00:29:30
Machine, a la máquina virtual de 00:29:32
Java, o la máquina virtual 00:29:34
del lenguaje que sea, si estuviéramos 00:29:46
con otro lenguaje que siguiera esta filosofía. 00:29:48
¿Qué es esto? Esto es un software 00:29:50
que, como bien sabéis, pues está 00:29:52
en todos los equipos y si no, pues uno lo descarga 00:29:54
y ya está. ¿Qué hace este software? 00:29:56
Es un software que 00:29:58
es capaz de ir interpretando una por una, 00:30:00
la máquina virtual de Java va interpretando, 00:30:04
interpreta el punto class 00:30:08
y lo va adaptando a la plataforma en la que lo está ejecutando. 00:30:12
Es decir, este punto class tiene ya mucho compilado. 00:30:30
Un segundo, tiene mucho compilado. 00:30:33
Pero tiene partes que todavía no. 00:30:35
Entonces, la máquina virtual de Java 00:30:38
va cogiendo las líneas 00:30:39
que no son líneas porque esto ya no es texto 00:30:42
va cogiendo los capsules del punto class 00:30:44
los va cogiendo 00:30:46
y los va ya convirtiendo en un ejecutable 00:30:47
ahora ya sí, uno por uno 00:30:50
van modo intérprete 00:30:52
los va a convertir en un ejecutable pero ya adaptado 00:30:53
adaptado a la máquina en la que estamos 00:30:56
¿que yo este punto class 00:30:58
lo llevo a ese equipo? 00:31:00
genial, la máquina virtual de ese equipo 00:31:02
lo interpreta sin problemas 00:31:04
¿que este punto class lo llevo a una tablet? 00:31:05
ningún problema, este mismo .class 00:31:07
la máquina virtual de mi tablet 00:31:10
lo va interpretando y adaptando 00:31:12
por eso se dice que Java es multiplataforma 00:31:14
porque las aplicaciones hechas 00:31:16
en Java son estos 00:31:18
son muchos ficheros .class 00:31:20
esto es una aplicación hecha en Java 00:31:22
muchos de estos 00:31:24
muchos de estos es una aplicación en Java 00:31:25
esto es, y la aplicación 00:31:28
Java que son muchos de estos 00:31:32
nada más que eso, muchos de estos 00:31:34
me da igual donde la ejecute 00:31:35
me da lo mismo 00:31:38
porque donde yo la ejecute 00:31:39
habrá una máquina virtual 00:31:41
porque si no la hay no puedo ejecutarlo, claro 00:31:43
habrá una máquina virtual, una Java Virtual Machine 00:31:44
que cogerá ese class 00:31:47
y ya lo interpretará y lo irá adaptando 00:31:49
¿vale? 00:31:51
claro, necesito que esta máquina virtual esté en el equipo 00:31:52
donde voy a ejecutar la aplicación 00:31:55
si no puede estar la máquina virtual, la aplicación Java no se puede ejecutar 00:31:56
claro, pero es que tú 00:31:59
Cuando tienes un equipo, tienes su máquina virtual 00:32:06
dejada. Cualquier equipo que es la que 00:32:09
está adaptada a ese equipo. 00:32:11
Cuando te descargas, de verdad que la máquina virtual 00:32:12
pues, esa máquina virtual 00:32:15
tiene ya la funcionalidad 00:32:16
de ir adaptando a la CPU que ella ve que hay ahí. 00:32:18
¿Vale? 00:32:22
¿Vale? 00:32:22
¿Compilado? 00:32:31
No, no, no. Está pre-compilado. 00:32:32
¿Vale? 00:32:35
Está, digamos, hecho como a trozos ya 00:32:36
de cosas, packs, que ya están 00:32:39
compiladas, pero luego hay que irlo 00:32:40
montando, y eso es lo que va haciendo la máquina 00:32:42
sí, como queráis llamando 00:32:45
¿vale? 00:32:48
o sea, tampoco os perdáis mucho en lo que hay 00:32:50
dentro del punto class, pensad que hay 00:32:52
una versión 00:32:54
que ya no es código fuente, sino que ya algo 00:32:56
hemos avanzado al código máquina 00:32:58
por tanto es más rápido que esto 00:33:00
porque aquel intérprete es que 00:33:02
parte del código fuente directamente 00:33:04
sin embargo aquí la máquina virtual 00:33:06
de Java, te parte de algo 00:33:08
que ya está en código máquina 00:33:10
y lo único es que le falta por hacer algunas cositas 00:33:11
para ya conseguir un ejecutable completo. 00:33:14
Y va el poquito a poco 00:33:17
cogiéndolo. 00:33:18
¿Vale? Por esto Java 00:33:20
no es interpretado puro 00:33:22
porque tiene esta 00:33:24
precompilación. Sin embargo, 00:33:26
Python sí es interpretado puro. No hay una máquina virtual 00:33:28
de Python. Se podría hacer una compilación después 00:33:30
si ya está en una máquina. Va a ser utilizado 00:33:32
en esa máquina específicamente. 00:33:34
Voy a llevármelo a un RAID. 00:33:36
Es una CPU específica. 00:33:38
y lo tengo en .class 00:33:40
¿podría hacer un compilado entero de eso ya? 00:33:41
crear un ejecutable 00:33:44
para llevarlo a un sitio que no tiene 00:33:45
máquina virtual de Java 00:33:47
no, que aunque lo tenga, pero que para dejarlo ya ejecutado 00:33:48
en ese software específico 00:33:51
no, o sea 00:33:52
tú, la aplicación va a ser esto 00:33:54
tú llevarlo a otro formato 00:33:57
no lo vas a llevar nunca 00:33:59
este es su formato final 00:34:01
el formato final de la aplicación siempre es este 00:34:02
y tú lo vas a ejecutar siempre 00:34:05
con esto, sea donde sea 00:34:07
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. 00:34:08
vale 00:34:24
entonces esto que tiene 00:34:28
pues no es tan lento como esto 00:34:30
no es tan 00:34:33
eficiente como esto 00:34:35
pero es multiplataforma 00:34:37
entonces tú pues te descargas de internet cualquier aplicación 00:34:38
Java y la puedes ejecutar sin problema 00:34:41
te descargas de internet 00:34:43
una aplicación hecha en C 00:34:45
ya compilada y funcionará o no 00:34:46
depende de si tu CPU es compatible o no 00:34:49
con la versión que se compiló 00:34:51
¿vale? 00:34:53
Vale, bueno, pues esto es más o menos el contexto en el que trabajamos 00:34:54
Entonces, nosotros arrancaremos a hacer nuestros códigos fuentes 00:34:59
Haremos esta compilación y ejecutaremos con la máquina virtual 00:35:05
Al principio vamos a ver cómo se hace esto, pues cómo se hace a pelos 00:35:11
Es decir, cómo funcionan las cosas 00:35:17
Escribo mi código fuente en un blog de notas 00:35:18
lo compilo con la herramienta de compilación 00:35:21
que me da Java 00:35:24
y luego ya lo ejecuto con esta máquina virtual 00:35:24
todo desde la consola 00:35:28
recordad siempre que la consola es 00:35:29
el que usa la consola es el que sabe hacer las cosas 00:35:31
¿vale? 00:35:34
luego ya, ¿qué ocurre? 00:35:35
que tenemos software que nos ayudan 00:35:37
y nos facilitan tareas 00:35:40
pero que eso no nos tape 00:35:41
cómo se hacen las cosas de verdad 00:35:43
entonces cuando ya entendamos 00:35:44
rápidamente este esquema 00:35:47
de trabajo bien 00:35:50
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. 00:35:51
nos facilita algunas de las tareas 00:36:28
en realidad las tareas 00:36:30
involucradas con programar son 00:36:33
escribir código fuente 00:36:35
o sea, teclear 00:36:37
teclas, código ASCII 00:36:38
llamar al compilador 00:36:40
y llamar a la máquina virtual 00:36:42
en realidad no hay más 00:36:44
pero claro, el entorno de desarrollo 00:36:45
¿qué hace? pues nos mete 00:36:48
un editor de texto bonito, más bonito que el blog de notas 00:36:50
para que tenga colorines 00:36:52
nos permite 00:36:53
que se compile solo el programa 00:36:56
sin tener yo que compilarlo específicamente 00:36:58
lo va a compilar automáticamente 00:37:00
para ejecutarlo me da un botoncito para que yo ejecute 00:37:01
pues esas chorradas 00:37:04
que quiero encontrar un error porque me ha dado un error 00:37:05
yo he ejecutado un programa y la consola me dice 00:37:08
error, no sé qué 00:37:10
pues el compilador me da unas pequeñas herramientas 00:37:11
de depuración 00:37:14
que son herramientas que 00:37:15
pues permiten en una ventanita 00:37:18
aparte que tú vayas viendo 00:37:20
lo que hay en cada una de tus variables 00:37:22
bueno, todas estas cosas ya las iréis viendo en entornos 00:37:24
de desarrollo, entonces 00:37:26
un entorno de desarrollo es un software 00:37:27
que nos facilita 00:37:30
la tarea de 00:37:32
hacer y ejecutar 00:37:34
un programa de principio a fin 00:37:36
ya está, pero ni programa por nosotros 00:37:37
ni nada, pues hacemos nuestro programa 00:37:40
y nos da botoncitos para ahorrarnos trabajo 00:37:42
nada más 00:37:44
pero no lo necesitamos en realidad 00:37:45
pero bueno, nos facilita algunas tareas 00:37:47
entornos de desarrollo 00:37:49
pues hay un montón para un montón de lenguajes 00:37:52
¿vale? 00:37:54
para Java 00:37:55
el más usado 00:37:57
es Eclipse 00:37:58
¿vale? que es el que usaremos nosotros 00:38:00
también, pero hay muchos para Java 00:38:04
está este, el NetBeans 00:38:07
hay muchos entornos de desarrollo 00:38:09
estos son los tres que más se usan 00:38:11
¿vale? bueno este 00:38:14
últimamente quizás se usa menos, pero bueno 00:38:15
yo creo que es el que se usa mucho 00:38:17
entonces, pues nosotros vamos a usar 00:38:18
en concreto este entorno de desarrollo 00:38:21
cuidado, no nos tenemos que perder 00:38:23
porque el entorno de desarrollo se abre 00:38:25
y parece que te hace cosas solo 00:38:27
no te hace nada solo 00:38:29
el entorno de desarrollo, como te meta código 00:38:31
él por iniciativa propia 00:38:33
lo mete mal, obviamente 00:38:34
entonces cuidado 00:38:36
bueno, pues usaremos este entorno 00:38:39
de desarrollo nosotros 00:38:41
y vamos a ver si aquí en la introducción 00:38:42
teníamos algo más 00:38:45
vale, aquí más o menos está lo que os he contado 00:38:46
pues por si alguien se ha perdido 00:38:49
pero bueno, no tiene mucho 00:38:52
vale, pues ya está 00:38:53
vale, a ver, bueno, lo único que no he dicho es 00:38:59
lo único que no he dicho es 00:39:03
en este proceso 00:39:07
de desarrollo 00:39:09
uno hace el código fuente 00:39:10
lo compila 00:39:12
lo compila si está en este proceso 00:39:14
o está aquí en este, claro, lo compila 00:39:17
puede ocurrir que 00:39:19
den errores 00:39:20
porque hayas escrito mal el código 00:39:22
a lo mejor en Java tú tienes que poner 00:39:24
system out y has puesto 00:39:26
SystemAuth con dos t's 00:39:29
has escrito mal el código, porque no has seguido 00:39:30
las reglas del lenguaje, no has seguido las reglas 00:39:32
pues eso se va a detectar 00:39:35
en el momento de compilar 00:39:37
recompilar en el caso de Java se va a detectar 00:39:38
y te va a salir un error de compilación 00:39:40
este programa está mal escrito 00:39:43
bueno, pues nada, arreglaremos los errores de compilación 00:39:44
vale 00:39:47
un error que ya no tiene ningún error de compilación 00:39:48
ninguno, ya puede 00:39:51
pasar a ser interpretado por la máquina virtual 00:39:53
cuando ya no tenga ningún error de compilación 00:39:55
Que no tenga ningún error de compilación 00:39:56
Significa que el programa está bien hecho 00:39:59
No, habremos hecho un programa sin errores de compilación 00:40:00
Pero que igual no hace lo que tiene que hacer 00:40:03
Hace otra cosa 00:40:05
O no solo eso, sino que nos da un error de ejecución 00:40:05
Que esos son los graves 00:40:10
Por ejemplo 00:40:11
Mi aplicación, mi programa 00:40:13
Está escrito 00:40:15
En lenguaje perfecto 00:40:17
No tiene ningún error 00:40:19
¿Qué es lo que hace? Pide un número 00:40:20
Pide otro número y te muestra la división 00:40:22
De uno y otro 00:40:25
perfectamente escrito, muy bien 00:40:26
ahora ya entramos en fase de ejecución 00:40:28
el programa te dice, introduzca un número 00:40:30
7, introduzca otro número 00:40:32
0, él hace 7 entre 0 00:40:34
¡pam! se te ha roto 00:40:37
se te ha roto porque no se puede 00:40:38
dividir por 0 00:40:41
es una indeterminación matemática 00:40:41
no se puede dividir por 0 00:40:44
entonces si no se puede dividir por 0 00:40:45
en todo el cuerpo de las matemáticas 00:40:48
solo se pueden hacer límites 00:40:50
¿cómo va a dividir por 0 una máquina virtual, una CPU? 00:40:51
por menos todavía 00:40:54
entonces, ese es un ejemplo de error de ejecución 00:40:55
un programa puede 00:40:59
compilar perfectamente 00:41:00
porque está bien escrito 00:41:02
pero a la hora de ejecutarlo 00:41:03
ha fallado, es un error de ejecución 00:41:05
esos son los graves, porque los de compilación 00:41:08
se detectan cuando tú estás ahí metido 00:41:10
en tu cuarto haciendo 00:41:12
pero los de ejecución se detectan 00:41:14
cuando ya se ha entregado tu programa 00:41:16
se lo has dado a alguien, topancho 00:41:18
y él va y ¡bom! ¡oye, vaya mierda me has dado! 00:41:19
esos son los graves, ¿vale? 00:41:22
los más complicados de detectar 00:41:23
¿cómo se detectan? 00:41:25
haciendo mil pruebas 00:41:27
antes de entregar un programa, haz mil pruebas 00:41:28
200.000, mete mil datos 00:41:31
y seguro que alguna vez te falle 00:41:33
a lo mejor hicimos una prueba, le di 7 00:41:35
le di 2 y me hizo la división perfecta 00:41:37
uy, me ha funcionado el programa estupendamente 00:41:40
¿qué te ha fallado? 00:41:42
que te han faltado pruebas, muchas pruebas 00:41:43
te han hecho la prueba, le doy 7 y le doy 10 00:41:45
¿vale? entonces 00:41:47
hay que evitar errores 00:41:49
en la medida de lo posible, errores de ejecución 00:41:51
haciendo todas las pruebas del programa 00:41:53
una vez que ya compila 00:41:55
por supuesto, los de compilación son los primeros 00:41:57
¿vale? 00:41:59
bueno, pues entonces 00:42:00
vale, pues ya está 00:42:01
de introducción en general 00:42:06
al proceso de programar un poquito así 00:42:08
por encima, sería esto 00:42:11
a partir de aquí ya entramos ya en 00:42:13
las cosas 00:42:14
concretas ya 00:42:17
de programación estructural 00:42:17
¿alguna pregunta? 00:42:20
duda, algo 00:42:21
nada de nada 00:42:23
todo está muy claro 00:42:26
vale, pues venga 00:42:28
os aseguráis de que lo tenéis todo en la cabeza 00:42:30
antes de mañana 00:42:33
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
68
Fecha:
16 de septiembre de 2024 - 17:39
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
42′ 36″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.19

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid