Saltar navegación

20260914 IntrProgr - 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 15 de septiembre de 2026 por Raquel G.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues a ver, dentro de esas ideas muy generales que están aquí recogidas, si lo descargamos para tenerlo como guía, bueno, pues entonces, ¿qué es un ordenador? 00:00:00
Esto no lo quiero. Esto sí. Vale. Ya sabemos que un ordenador tiene una arquitectura, los que habéis hecho grado medio lo sabéis mejor que los demás, los que no lo sabéis da un poco igual. 00:00:19
Podemos hacer un resumen, que veréis más detallado en sistemas, de que un ordenador tiene una arquitectura de una CPU que está recibiendo continuamente instrucciones que están alojadas en su memoria RAM. 00:00:32
esas instrucciones que va recibiendo 00:00:47
las va ejecutando 00:00:50
esas instrucciones son 00:00:51
desde 00:00:54
lo que hace el sistema operativo 00:00:54
pues cuando tú le das doble clic a un icono 00:00:58
recibe la CPU 00:01:00
las instrucciones de 00:01:02
abre el icono 00:01:04
muestra lo que hay dentro 00:01:06
eso es un ordenador 00:01:07
una CPU que tiene una secuencia enorme 00:01:09
de sentencias en su memoria RAM 00:01:12
que se van entregando 00:01:15
de forma secuenciada 00:01:17
y la CPU 00:01:19
las va ejecutando 00:01:21
y esas sentencias son de todo tipo 00:01:22
lo que el sistema operativo le va mandando 00:01:25
que haga 00:01:27
que tú ejecutas un programa que has hecho tú 00:01:27
pues en particular ese programa 00:01:31
todo, una secuencia de cosas 00:01:33
todo el rato 00:01:34
desde el momento en que se arranca 00:01:35
claro, cuando el ordenador 00:01:39
se arranca 00:01:40
en el momento de arrancarse en la RAM 00:01:42
creo que más o menos todos sabemos 00:01:46
pero bueno, sistemas informáticos 00:01:49
estudias con detalles 00:01:51
en la RAM no hay nada, la RAM es la memoria que está vacía 00:01:52
en la RAM no hay nada 00:01:55
solo hay cosas cuando el ordenador ya ha arrancado 00:01:56
entonces 00:01:59
una pequeña 00:02:01
memoria que no se borra nunca 00:02:03
una pequeña memoria que no se borra nunca 00:02:05
que es la memoria BIOS 00:02:07
pues coge 00:02:08
desencadena todo el proceso 00:02:11
para que se cargue en RAM 00:02:14
lo primero que hay que ejecutar 00:02:17
se cargan esas primeras sentencias 00:02:20
eso ya se empieza a ejecutar 00:02:22
a partir de ahí se van dando órdenes 00:02:24
para que se vayan cargando las siguientes, etc. 00:02:25
y eso es lo que hace un ordenador 00:02:28
de principio a fin, desde que le damos a load 00:02:29
hasta que le damos a load 00:02:31
ir cogiendo sentencias que están en la RAM 00:02:33
irlas ejecutando 00:02:35
e irnos mostrando los resultados 00:02:37
¿vale? 00:02:38
bueno, la suerte que tenemos es que lo hace muy rápido 00:02:41
entonces nosotros aprovechamos de eso 00:02:44
que tenemos que resolver una tarea 00:02:46
por ejemplo 00:02:48
pues tengo que dar el ok 00:02:49
a 28.000 00:02:52
facturas 00:02:54
pues hombre, un humano dar el ok 00:02:55
a 28.000 facturas 00:02:58
pues tendría que ir factura por factura 00:02:59
sería muy lento 00:03:02
nos aprovechamos de que el ordenador lo hace muy rápido 00:03:03
esas facturas 00:03:06
las digitalizamos 00:03:08
y hacemos un programa 00:03:11
que es capaz 00:03:13
de leer los datos que constituyen las facturas, leer los datos, ir poniendo el ok y generando el resultado, etc. 00:03:13
Entonces nos aprovechamos de que la CPU hace lo que nosotros sabemos hacer muy rápido. 00:03:22
¿Qué ocurre? Que a la CPU hay que decirle cómo hacerlo y con qué hacerlo, pues con qué datos. 00:03:29
Entonces, es fundamental dos cosas. 00:03:38
¿Con qué datos tienes que trabajar? 00:03:40
¿Y qué tienes que hacer? 00:03:43
¿Cómo lo tienes que hacer? 00:03:45
Pues eso es un programa. 00:03:46
Eso es lo que nosotros hacemos. 00:03:48
Un conjunto ordenado de instrucciones que el ordenador ya es capaz de ejecutar. 00:03:51
Nosotros nos plantean un problema. 00:03:56
Vale, pues voy a decidir diseñar cómo elaboro un conjunto de instrucciones para conseguir este objetivo. 00:03:59
Cuando ya lo tenga perfectamente elaborado, diseñado, etc., ya mi ordenador lo ejecutará y lo hará en un microsegundo. 00:04:07
Si yo lo hubiera tenido que hacer a mano, habría tardado muchísimo más. 00:04:15
Pero eso sí, a él hay que decirle cómo hacerlo paso a paso, cómo hacerlo paso a paso. 00:04:19
Pues eso es un programa, el conjunto ordenado de instrucciones. 00:04:24
Y eso es lo que nosotros hacemos, elaborar ese conjunto ordenado de instrucciones. 00:04:27
entonces hay conceptos que aunque nosotros no nos metemos en ellos 00:04:32
porque no nos importan especialmente 00:04:38
tenemos que saber por cultura informática 00:04:40
por cultura como desarrolladores hay conceptos que tenemos que saber 00:04:43
esos conceptos son un poquito de los que voy dando pinceladas 00:04:47
a lo largo del documento 00:04:51
entonces una vez que está claro 00:04:53
que un programa es un conjunto de instrucciones 00:04:55
que mi ordenador ejecuta 00:04:59
Ahora ya surgen un montón de preguntas 00:05:01
Y es 00:05:04
¿Y cómo escribo yo esas instrucciones? 00:05:05
Porque 00:05:09
¿Qué le digo yo al ordenador? 00:05:09
Oye, pon un ok en la factura 00:05:11
Y no me va a entender, lógicamente 00:05:12
¿Por qué no me va a entender? 00:05:14
Porque nosotros 00:05:18
Todos sabemos perfectamente 00:05:19
Que la CPU que está aquí 00:05:21
Este bicho de aquí 00:05:23
Solo es capaz de entender 00:05:24
Lo que le pasemos al lenguaje binario 00:05:27
solo es capaz de entender esto, nada más 00:05:30
entonces 00:05:32
le tenemos que dar la secuencia 00:05:34
de instrucciones a la CPU 00:05:36
en binario, en ceros y unos 00:05:38
que es lo único 00:05:40
que es capaz de ser 00:05:42
almacenado en la memoria 00:05:44
en la RAM, en la RAM solamente 00:05:46
en ceros y unos, ya está 00:05:48
jolín, pues madre mía 00:05:49
escribir un programa en ceros y unos 00:05:52
que es el lenguaje 00:05:55
y puede entender la CPU 00:05:56
menuda tarea interminable 00:05:57
un rollo, ¿quién es capaz de hacer eso? 00:05:59
pues antiguamente se hacía 00:06:04
antiguamente se hacía 00:06:05
hace 60, 70 años 00:06:07
a lo mejor no directamente en ceros y unos 00:06:09
lógicamente 00:06:12
sino en un lenguaje 00:06:13
que se llamaba ensamblador 00:06:15
que era una cosa 00:06:17
como muy esotérica 00:06:23
que ahora mostramos una imagen para que lo veáis 00:06:24
que eran unas palabras súper raras 00:06:27
unos símbolos muy extraños 00:06:30
que directamente 00:06:31
era muy fácil de traducir 00:06:33
a ceros y unos 00:06:35
o sea, programar, escribir las sentencias 00:06:36
en ensamblador 00:06:39
y escribirlas en ceros y unos era casi casi igual 00:06:40
hombre, en ensamblador 00:06:43
era un poquito más fácil 00:06:45
porque al menos eran términos más humanos 00:06:46
ahora veremos un programa en ensamblador 00:06:49
entonces luego había ya 00:06:51
unos pequeños 00:06:53
programas, dispositivos 00:06:55
que eran capaces ya de 00:06:57
traducir esto 00:06:59
que estaba en ese lenguaje extraño 00:07:01
traducirlo ya a ceros y unos 00:07:03
y cargarlo en la RAM 00:07:05
¿vale? 00:07:06
pues el lenguaje ensamblador es ese 00:07:08
un lenguaje que está 00:07:10
se dice que está muy pegado a la máquina 00:07:11
porque le da las instrucciones 00:07:14
completamente al detalle 00:07:16
como la máquina las necesita 00:07:18
que es todas detalladas 00:07:19
absolutamente deglutidas en ceros y uno 00:07:21
por ejemplo 00:07:23
muéveme, tú tenías que sumar 00:07:25
dos números 00:07:27
Pues para dar las instrucciones a la CPU hay que dárselas 00:07:28
Coge el primer número y llévalo al registro en el que tú tienes un operador 00:07:33
Ahora, coge el segundo número y muévelo al otro registro que tienes ahí habilitado para el otro operador 00:07:39
Ahora, por favor desencadena en tu unidad aritmético-lógica que tienes ahí dentro 00:07:47
Que la CPU tiene dentro una unidad aritmético-lógica para hacer operaciones 00:07:53
desencadena la acción 00:07:58
de sumar en binario 00:08:00
combinando ceros y unos con puertas lógicas 00:08:02
y guárdame 00:08:05
y lo que se te quede 00:08:07
déjalo aquí en uno de los operadores 00:08:08
con esa combinación de puertas lógicas 00:08:10
ahora este resultado 00:08:12
muévelo por favor al bus 00:08:15
para que salga 00:08:17
por pantalla 00:08:18
todo eso es lo que necesita la CPU 00:08:20
todo ese detalle 00:08:23
así, ese nivel de detalle necesita 00:08:24
la CPU solo entiende ese nivel de detalle 00:08:26
para cualquier cosa, imaginaos la cantidad 00:08:30
de cosas que le he dicho 00:08:31
para sumar dos números 00:08:32
primero que mueve hasta aquí, luego que mueva este aquí 00:08:35
luego que haga esa secuencia de operaciones 00:08:37
con puertas lógicas para que los ceros y unos 00:08:40
funcionen como una suma 00:08:42
luego que lo lleve al bus 00:08:43
todo eso para sumar dos números 00:08:45
pues sí, eso es lo que hay que decir 00:08:48
de la CPU, es que no hay rutía 00:08:49
entonces esas sentencias que se le dicen 00:08:51
en secuencia de ceros y unos 00:08:53
era más fácil programarlas en este lenguaje 00:08:55
que aún así, repito, era muy 00:08:58
farragoso, muy engorroso, había que decirle todo eso 00:09:01
en un lenguaje un poquito más natural 00:09:04
sí, pero aún así muy farragoso 00:09:07
esto ya se traducía a ceros y unos 00:09:09
por unos sobreensambladores que se llamaban y esto ya se ejecutaba 00:09:12
¿vale? entonces para que nos hagamos una idea 00:09:15
buscamos 00:09:19
vale, si buscamos por ejemplo 00:09:24
aquí 00:09:36
ejemplo 00:09:37
ensamblador 00:09:42
solo para que os hagáis una idea 00:09:44
no tengo aquí una imagen 00:09:46
chula 00:10:08
del lenguaje ensamblador 00:10:09
yo quiero ver esta imagen 00:10:11
se me ha colado aquí 00:10:23
por ejemplo, esto es un programa 00:10:32
en código ensamblador 00:10:49
veis estas sentencias tan raras 00:10:51
esto 00:10:55
hacía cualquier chorrada 00:10:57
cualquier tontería 00:10:59
a lo mejor una operación sencilla 00:11:00
mete este dato aquí 00:11:01
estos son registros de la CPU 00:11:04
que directamente había que poner en el ensamblador 00:11:06
ahora mueve este registro a este otro registro 00:11:08
ahora no sé qué 00:11:10
ahora quítale a este registro lo que tiene este 00:11:12
todo esto para hacer una chorrada 00:11:14
esto luego se traducía a ceros y unos 00:11:15
de forma inmediata, aquí en esta anexa decimal 00:11:18
pero esa decimal y los 0 y 1 son lo mismo 00:11:21
se traducía, y esto ya la CPU 00:11:23
lo entendía 00:11:25
programar el ensamblador 00:11:26
la desventaja que tenía 00:11:29
era que cada CPU 00:11:31
tiene 00:11:33
su propio conjunto de secuencias 00:11:35
propias, entonces el lenguaje 00:11:37
el programa que funcionaba 00:11:39
para una CPU 00:11:41
no te funcionaba para otra, porque cada CPU 00:11:42
cada marca 00:11:45
o sea, cada marca, me refiero, cada modelo. 00:11:46
Cada modelo de CPU tiene su propio conjunto 00:11:50
de instrucciones en 0.1, cada modelo de CPU. 00:11:53
Entonces, tú hacías un programa en ensamblador 00:11:57
para un modelo de CPU, una Intel no sé cuántos, 00:11:59
y solo te funcionaba para la CPU Intel no sé cuántos. 00:12:03
Si querías hacer eso mismo, pero ejecutar un ordenador 00:12:06
que tenía un microprocesador AMD no sé qué, 00:12:09
tenías que hacer el programa para la CPU AMD no sé qué. 00:12:13
O sea, cada modelo de CPU tenía su propio conjunto de sentencias. 00:12:16
Bueno, así salían programas estupendos y maravillosos, 00:12:23
absolutamente optimizados a la CPU, rapidísimos y magníficos. 00:12:27
¿Qué ocurre? 00:12:32
Que programar así ya ha perdido el sentido completamente. 00:12:33
Esto tenía su sentido cuando la envergadura de los programas era limitada. 00:12:37
Tú no tenías miles de millones de datos. 00:12:41
No tenías interfaces gráficas súper complicadas. 00:12:43
a lo mejor todo era por consola 00:12:46
entonces se podía o no permitir programar así 00:12:47
¿vale? ahora ya no 00:12:49
si tuviéramos que hacer cualquiera de los programas 00:12:51
que hacemos ahora con sus interfaces gráficas 00:12:53
sus conexiones a servidores de bases de datos 00:12:55
sus cargas de 200.000 millones de usuarios 00:12:58
si tuviéramos que hacer así 00:13:01
obviamente nos volveríamos locos 00:13:02
¿vale? pues entonces 00:13:04
¿qué es lo que ha surgido? 00:13:05
¿qué es lo que surgió? 00:13:07
¿vale? pues surgieron los lenguajes 00:13:11
de alto nivel 00:13:14
¿vale? 00:13:15
¿Qué es un lenguaje de alto nivel? Es un lenguaje de programación en el que tú ya te abstraes y ya escribes en un lenguaje muy natural. 00:13:17
Entonces, el ejemplo que he dicho antes de voy a hacer un programa al que yo le dé dos números y me lo suma, 00:13:26
que en ensamblador era muchas instrucciones, en un lenguaje de alto nivel el programa a lo mejor es simplemente, pues ya está, esto, 00:13:31
¡hala!, ya está, una única sentencia de código para hacer ese programa. 00:13:45
Esto en lenguaje de alto nivel 00:13:49
En ensamblador, una ristra de cosas 00:13:52
¿Lenguajes de alto nivel? 00:13:55
Pues todos los que conocéis 00:13:58
C, Python, Java, todos 00:14:00
¿Qué ocurre? 00:14:02
Que la CPU 00:14:04
Esto no lo entiende 00:14:05
Ya hemos quedado con que la CPU entiende 00:14:07
El minario 00:14:10
Que es prácticamente idéntico al ensamblador 00:14:11
La CPU esto no lo entiende 00:14:14
No pasa nada 00:14:16
Ya, afortunadamente, tenemos un proceso automático que permite convertir un programa hecho en un lenguaje de alto nivel en código binario. 00:14:18
Afortunadamente, eso existe y nosotros como desarrolladores nos podemos olvidar de esa parte. 00:14:32
Escribimos en nuestro lenguaje de alto nivel, que es mucho más sencillo de expresar lo que queremos hacer, 00:14:37
y ya lanzamos el proceso para que esto se traduzca a los ceros y unos 00:14:43
y el ordenador lo ejecute, el ordenador ya encantado con sus ceros y unos 00:14:49
lanzamos el proceso, ¿y ese proceso cuál es? 00:14:53
pues de nuevo son términos que nos tienen que ir sonando a los que no nos suenen 00:14:57
nuestra cultura informática es fundamental 00:15:00
vosotros, cualquier empresa, con cualquiera que habléis 00:15:05
cualquier compañero, vais a una 00:15:11
habéis solicitado una beca 00:15:13
habéis hecho una entrevista de trabajo, lo que sea 00:15:15
tenéis que poco a poco 00:15:16
ir ya adquiriendo 00:15:18
unos conocimientos que os permitan 00:15:21
hablar con unos términos que se vea que se sabe 00:15:23
que se sabe donde estáis 00:15:25
que conocéis el contexto, etc. 00:15:27
Bueno, pues entonces, ¿cuál es el proceso 00:15:29
para traducir 00:15:31
este código 00:15:33
escrito en un lenguaje de alto 00:15:35
nivel que se llama código 00:15:37
fuente? 00:15:39
El código fuente es el código que yo he escrito en lenguaje de alto nivel ya, el facilito. 00:15:42
Pues, ¿cuál es el proceso para llevarlo a los ceros y unos? 00:15:48
Que los ceros y unos son el ejecutable. 00:15:51
Los ceros y unos son el ejecutable. 00:15:54
Bueno, pues el proceso, hay pequeñas variantes, muy, muy por encima estamos dando las ideas, muy por encima. 00:15:57
Vale, primero, lógicamente, escribimos el código fuente utilizando el lenguaje de programación que hayamos elegido. 00:16:04
Por supuesto, escribimos el código fuente cuando ya hemos pasado lo importante y lo que lleva tiempo, 00:16:11
que es pensar el programa, diseñar cómo los pasos, cómo lo voy a hacer, voy a usar esto, estas variables para tiempo. 00:16:18
Una vez que lo tengo ya todo pensado, ya me voy a lo que es fácil, que es a tirar el código. 00:16:24
Bueno, pues escribimos el código fuente, utilizando el lenguaje de programación seleccionado. 00:16:29
¿Vale? Entonces, ese código, ahora, ¿cómo se transforma en el código ejecutable? También se puede llamar código máquina, ¿vale? Código ejecutable, código máquina serían sinónimos. Ejecutable o código máquina. ¿Cómo se transforma? Pues se puede hacer de diferentes formas. 00:16:34
compilación 00:16:55
existe un programa 00:16:58
compilador, un software compilador 00:17:01
que afortunadamente 00:17:03
no tenemos que hacer nosotros 00:17:04
nosotros disponemos ya del compilador 00:17:06
cualquiera que programa 00:17:09
cualquier lenguaje de programación tiene ya el compilador 00:17:11
no tiene que preocuparse por eso 00:17:13
y ese compilador que hace 00:17:14
recibe el código fuente que nosotros 00:17:16
hemos hecho, recibe ese código fuente 00:17:19
y saca el código ejecutable 00:17:21
y ya está, y una vez que lo ha sacado 00:17:23
pim pim, tú ya lo ejecutas 00:17:25
¿vale? 00:17:27
entonces, diseñamos la solución 00:17:29
la escribimos en código fuente 00:17:31
se la pasamos al compilador 00:17:33
el compilador 00:17:35
saca por arte de magia 00:17:37
un ejecutable que ya 00:17:39
se puede ejecutar 00:17:41
en función de 00:17:42
cómo se está bajando yo, con doble clic o como sea 00:17:43
pero que ya se puede ejecutar 00:17:47
y que la CPU lo entiende 00:17:49
esto es un proceso 00:17:50
pues bastante rápido 00:17:53
pero tiene ciertas desventajas 00:17:54
que vamos a ir entendiendo ahora o después 00:18:01
bueno, alternativas a la compilación 00:18:03
para este proceso de traducir 00:18:06
el código fuente en el código ejecutable 00:18:09
alternativas a la compilación 00:18:13
la interpretación 00:18:14
en lugar de un software compilador 00:18:16
tenemos un software intérprete 00:18:20
que se llama. ¿Y ese intérprete qué va haciendo? En lugar de coger todo el código 00:18:24
fuente de golpe y convertirlo en un código ejecutable y ya está, ese código ejecutable 00:18:29
se queda ya de por vida ahí, listo para que uno lo ejecute. Pues en lugar de hacer eso, 00:18:35
ese software intérprete se lanza y está ahí en el ordenador, cogiendo línea por 00:18:41
línea el código fuente, la va cogiendo línea por línea y tal cual la coge, la ejecuta, 00:18:46
La coge y la ejecuta, la coge y la ejecuta, la coge y la ejecuta, la coge y la transforma al código binario, cuando digo la ejecuta, la transforma en binario para poder ejecutar, o sea, va, coge, código binario, ejecución, coge la siguiente, código binario, ejecución, ¿vale? 00:18:51
entonces 00:19:08
ventajas, inconvenientes 00:19:11
esto es mucho más rápido de ejecutar 00:19:13
una vez que tú has compilado el programa 00:19:18
una vez que lo has compilado 00:19:20
ese código máquina 00:19:21
ya se ejecuta a toda velocidad 00:19:23
ya está compilado, ya son todos 0 y 1 00:19:25
es mucho más rápido, la ejecución de los programas 00:19:27
que han sido compilados es mucho más rápido 00:19:30
es mucho más rápido 00:19:32
la ejecución de los programas compilados 00:19:33
sin embargo aquí, cada vez que quieres ejecutar 00:19:35
uno de estos, tienes que lanzar 00:19:38
el intérprete, el intérprete 00:19:40
va transformando línea por línea 00:19:42
ejecutando, transformando, ejecutando 00:19:44
luego es mucho más lenta 00:19:46
la ejecución, así 00:19:48
porque hay que interpretarlo 00:19:50
cada vez, cada vez que lo quieres 00:19:52
ejecutar lo interpretas, o sea, no se genera 00:19:54
un ejecutable que te vale ya para siempre 00:19:56
no se genera un ejecutable que te vale para siempre 00:19:57
entonces diríais 00:19:59
pues ¿para qué 00:20:02
existe ese método? 00:20:04
es mucho mejor la compilación 00:20:05
Yo lo compilo, tengo ya mi ejecutable ahí, cada vez que lo quiera ejecutar a toda velocidad ya. 00:20:07
No tengo que hacer nada más. 00:20:13
¿Para qué existe esto? 00:20:15
Pues existe para poder adaptarse a que hay diferentes modelos de máquinas 00:20:19
y que nosotros querríamos que un programa que acabamos de hacer se pudiera ejecutar en cualquier máquina. 00:20:26
y que ocurre cuando el compilador 00:20:32
yo le doy un código fuente 00:20:36
y lo compila en el ejecutable 00:20:37
pues que ese ejecutable es válido 00:20:39
solo para el modelo 00:20:41
de CPU para que ese compilador 00:20:43
lo compiló, solo es válido 00:20:45
para ese modelo, entonces para ese modelo de CPU 00:20:47
va estupendo, rapidísimo 00:20:49
magnífico, pero si yo ese 00:20:51
programa que ya he compilado y he generado el binario 00:20:53
lo quiero llevar a otro 00:20:55
modelo de CPU, pues seguramente 00:20:57
no me funciona, y tengo que compilarlo 00:20:59
de nuevo en esa CPU 00:21:01
entonces cuando yo distribuyo un software por ahí 00:21:02
por la vida, por el mundo 00:21:05
si yo distribuyo un ejecutable 00:21:06
pues solamente 00:21:09
van a poder ejecutar mi programa 00:21:11
los que tengan el mismo modelo 00:21:13
de CPU para el que yo ejecute 00:21:15
mi compilación 00:21:17
¿me estoy explicando? 00:21:18
entonces eso es poco operativo 00:21:21
sobre todo ahora que distribuimos software 00:21:23
en el contexto de internet 00:21:25
yo no quiero poner esa limitación 00:21:27
de que solamente vale para el modelo 00:21:29
de Intel no sé cuándo, quiero ponerla 00:21:31
pues para eso está la interpretación 00:21:32
porque 00:21:35
cuando tú haces un software 00:21:36
que es 00:21:39
interpretado 00:21:40
tú entregas tu código fuente 00:21:42
aquel al que se lo has distribuido 00:21:46
tiene su intérprete 00:21:49
cuando quiere ejecutar tu programa 00:21:50
lanza su intérprete 00:21:53
y el intérprete 00:21:55
coge tu código y lo transforma 00:21:56
a tu propia máquina 00:21:59
coge tu línea de código 00:22:00
y lo transforma a tu propia máquina 00:22:03
entonces tú haces tu software 00:22:04
y te olvidas completamente 00:22:06
de en qué máquina se va a ejecutar 00:22:08
te va a funcionar para todas 00:22:10
siempre y cuando esa máquina tenga el intérprete 00:22:11
eso sí, está obligado a tenerlo 00:22:14
tú haces tu código, lo distribuyes 00:22:16
y ahí donde se quiera ejecutar 00:22:18
esa máquina tiene que tener 00:22:20
su intérprete 00:22:22
y lo va interpretando a tu propia máquina 00:22:23
a la que sea 00:22:26
Luego es mucho más universal 00:22:27
Pero claro, viejo, pues es universal 00:22:30
Pero realmente es que es un rollo, primero 00:22:34
¿Tienes que distribuir el código fuente siempre? 00:22:36
Por un lado no está mal 00:22:40
No está mal la idea de que el software 00:22:41
Pues sea lo más libre posible 00:22:42
Dentro de las licencias que lo regulen 00:22:44
Pero hombre 00:22:46
Tener que distribuir el código fuente siempre 00:22:48
Pues es medio raro 00:22:51
Aparte de que realmente es que es muy lento 00:22:53
interpretar línea por línea de un código fuente 00:22:56
cada vez, cada ejecución sería lentísima 00:22:58
vale, pues para no perder las ventajas 00:23:01
de poder ser ejecutado en cualquier máquina 00:23:05
pero ganar un poco de rapidez 00:23:07
es por lo que 00:23:09
salen los sistemas mixtos 00:23:11
vale 00:23:12
entre los cuales forma parte 00:23:14
Java 00:23:16
Python es un interpretado más puro 00:23:17
por eso tiene un menor uso comercial 00:23:20
tiene un más uso universitario 00:23:23
porque es como más fácil 00:23:24
para, tiene unas librerías 00:23:27
muy buenas a nivel científico 00:23:29
pero es más 00:23:31
puramente interpretado, entonces es un poquito más lento 00:23:36
y Java 00:23:39
si es un sistema mixto que combina las dos cosas 00:23:40
y diréis, ¿y cómo 00:23:43
mezclo las dos cosas? 00:23:44
vale, pues nosotros hacemos 00:23:47
nuestro código en Java, que es el lenguaje 00:23:48
al que vamos a trabajar nosotros, hacemos nuestro código 00:23:50
hacemos una 00:23:52
pequeña precompilación 00:23:55
eso no lo lleva 00:23:57
a código máquina de ningún 00:23:59
modelo de CPU, no 00:24:01
lo lleva a un código intermedio que ya no es 00:24:03
un código fuente que uno pueda ver 00:24:05
porque está en ceros y unos 00:24:07
lo lleva a un código intermedio 00:24:09
que es lo que se llaman los bytecodes estos de aquí 00:24:10
lo lleva a un código 00:24:13
intermedio que es los bytecodes 00:24:15
y ahora ya ese bytecode 00:24:16
que es un código intermedio precompilado 00:24:19
es el que distribuyes 00:24:21
Cuando uno distribuye software hecho en Java, distribuye esto. Y ahora, en cada máquina que uno quiera ejecutar ese software que te han distribuido, esa máquina tiene que tener el intérprete de Java. Por eso todos nuestros ordenadores tienen la Java Virtual Machine, la JVM, que es el intérprete de Java. 00:24:24
si tú no tienes un intérprete de Java en tu equipo 00:24:46
no podrás ejecutar nunca programas 00:24:50
que se han hecho en Java 00:24:52
vale, pues este intérprete 00:24:53
de Java es ya el que 00:24:56
es capaz de entrar 00:24:58
dentro de este bytecode 00:24:59
que es igual para todos 00:25:01
los equipos, igual 00:25:04
y ya lo va traduciendo a la máquina 00:25:05
en particular en la que tú lo estás ejecutando 00:25:08
entonces por eso Java 00:25:10
un software en Java es universal 00:25:12
tú lo haces y no necesitas 00:25:14
saber en qué máquina se va a ejecutar 00:25:15
te da igual, va a funcionar para todas 00:25:18
tú haces tu programa 00:25:20
haces esa primera 00:25:22
precompilación 00:25:24
donde obtienes esto 00:25:25
esa primera precompilación 00:25:27
y ahora ya distribuyes eso 00:25:29
que eso no es código fuente, tú lo ves y ahí no ves nada 00:25:31
no ves nada 00:25:34
y ahora ya en el ordenador 00:25:35
donde tú lo quieras ejecutar 00:25:38
lanzas la máquina virtual de Java 00:25:39
y esta máquina virtual de Java 00:25:42
va traduciendo esto, lo va interpretando 00:25:44
ahora ya sí, línea por línea 00:25:45
de algo que no se ve 00:25:48
o sea que no lo puedes entender leyéndolo 00:25:49
ahora ya sí que va traduciendo 00:25:52
línea por línea 00:25:53
para que se ejecute en la máquina 00:25:55
entonces al no ser interpretado puro 00:25:56
no es tan lento como los 00:25:59
interpretados puros 00:26:01
pero al no ser completamente compilado 00:26:02
es independiente de la plataforma 00:26:05
¿vale? 00:26:08
o sea un lenguaje independiente 00:26:09
de la plataforma significa 00:26:11
tú programas 00:26:13
y te da igual en qué equipo 00:26:15
o plataforma se ejecute 00:26:18
porque va a funcionar para todos 00:26:20
eso es un programa independiente de la plataforma 00:26:21
y así lo son los interpretados y los mixtos 00:26:23
los compilados no lo son 00:26:26
un programa que tú 00:26:28
lo has compilado completamente 00:26:30
solo va a funcionar en la máquina 00:26:31
en el modelo 00:26:33
en el modelo de máquina para el cual lo has compilado 00:26:35
¿vale? 00:26:37
luego entonces, hasta ahora 00:26:41
Tenemos ahora ya que tener utilizado en la cabeza. ¿Qué es un programa? Una lista de instrucciones para que la CPU realice una tarea. Esa lista de instrucciones la habremos diseñado, lógicamente, antes nosotros. 00:26:42
el lenguaje ensamblador 00:26:57
es un lenguaje muy próximo a la máquina 00:26:59
donde se detalla paso por paso 00:27:02
lo que es la CPU de Azure 00:27:04
como ese detalle paso por paso 00:27:05
es muy complejo 00:27:08
tenemos los lenguajes de alto nivel 00:27:09
los lenguajes de alto nivel 00:27:12
nos permiten programar 00:27:14
de forma más sencilla porque en una sola 00:27:16
sentencia la CPU va a hacer 00:27:18
ya mil cosas 00:27:20
en una sola sentencia la CPU ya hace mil 00:27:20
pero claro, ese código escrito 00:27:23
en lenguaje de alto nivel, que es el que se llama código fuente, 00:27:26
ese código fuente tiene que pasar a código ejecutable 00:27:30
o código mágico. ¿Cómo? 00:27:33
Pues con compilación, con un compilador, interpretación, con un intérprete 00:27:38
o combinando ambos. ¿Vale? Entonces todos los 00:27:42
términos y el contexto están claros, ¿no? 00:27:46
Bueno, entonces, lógicamente 00:27:49
nuestros programas, pues cuando hacemos 00:27:54
nuestros programas, hacemos una 00:27:56
primera versión, nos parece que 00:27:58
ostras, pues que guay, esto seguro que funciona 00:28:00
empezamos a lanzar 00:28:02
los programas y las cosas fallan 00:28:04
lo normal es que fallen 00:28:05
entonces tenemos que distinguir 00:28:07
dos tipos de errores 00:28:10
los de compilación 00:28:12
lo que llamamos 00:28:14
error de compilación 00:28:16
esto es lo más sencillo de detectar 00:28:18
un error de compilación es un error 00:28:22
Que se da cuando tú escribes 00:28:24
El código fuente mal 00:28:27
El código fuente tiene unas reglas 00:28:28
O sea, el lenguaje de alternativa tiene unas reglas 00:28:30
Tú no puedes poner lo que te dé la gana 00:28:32
Tiene unas reglas 00:28:33
Pues si quieres hacer el resto de una cosa entre otra 00:28:34
Tienes que poner el operador este 00:28:38
Tiene sus reglas 00:28:41
Que son las que tenemos que conocer 00:28:42
Entonces, si tú 00:28:44
Lo escribes mal 00:28:46
Quieres escribir 00:28:47
Cabo 00:28:50
haciendo la analogía al lenguaje natural 00:28:52
y escribes así porque no conoces 00:28:55
la ortografía 00:28:58
pues el corrector ortográfico de Word 00:28:59
te dice, eh, esta palabra 00:29:01
no la conozco, no la entiendo 00:29:03
pues eso 00:29:05
traducido al contexto de escribir en un lenguaje 00:29:07
de alto nivel sería el error de compilación 00:29:10
que lo que tú has escrito 00:29:12
no se corresponde con la sintaxis 00:29:13
del lenguaje, no existe 00:29:16
no tiene sentido 00:29:18
a esos errores se les llama errores de compilación 00:29:18
son los mejores que te pueden salir 00:29:22
porque te salen antes de que tú le hayas entregado 00:29:24
el programa a nadie para que lo ejecute 00:29:26
porque es que un error, un programa que tiene un error 00:29:28
de estos de compilación 00:29:30
es que no se puede ni compilar, ni interpretar, ni nada 00:29:31
no se le puede hacer nada 00:29:34
porque es que no está 00:29:36
bien escrito en el lenguaje 00:29:38
el compilador te va a decir 00:29:40
esto que me has pasado no está en mi idioma 00:29:41
o el intérprete te va a decir 00:29:44
esto que me has pasado no está en mi idioma 00:29:46
entonces no va a llegar a ejecutarse nunca 00:29:48
Nadie te va a decir, ¿me has dado algo de lo que funciona? 00:29:50
No, es que no vas a poder haberse lo dado. 00:29:52
Porque no vas a poder haberlo ni compilado ni interpretado. 00:29:54
Porque se van a haber quejado antes. 00:29:57
Vale, eso es lo que se llama errores de compilación. 00:30:00
Cuando tú escribes mal el código fuente, y eso no se entiende, 00:30:02
y luego tú puedes haber escrito un código fuente perfectísimamente, 00:30:10
el compilador lo compila, porque compila perfectamente, 00:30:14
eso está muy bien escrito, 00:30:18
o si es un lenguaje interpretado 00:30:19
el intérprete 00:30:21
traduce perfectamente las líneas 00:30:23
porque están muy bien escritas 00:30:25
tú has escrito la frase 00:30:26
en código fuente perfectamente 00:30:28
¿vale? pero cuando el programa 00:30:30
ya se ejecuta 00:30:33
¡pum! falla 00:30:34
pues es un error de ejecución 00:30:36
y es que tu programa está mal hecho 00:30:38
está mal hecho 00:30:41
está bien escrito 00:30:42
pero está mal hecho 00:30:43
¿vale? 00:30:45
claro, tú escribes 00:30:49
la casa come 00:30:50
una frase perfecta, sintácticamente 00:30:52
no tiene ningún error 00:30:55
pero luego pon tú a dar de comer a una casa 00:30:56
no vas a conseguirlo, cuando tú ves de comer a una casa 00:30:59
la casa no puede comer 00:31:01
porque no es un humano, ni un animal 00:31:02
entonces, ahí tienes un error 00:31:05
al momento de llevarlo a la práctica 00:31:07
lo has escrito perfectamente 00:31:08
pero eso no puedes llevarlo a la práctica 00:31:10
esos son los peores errores 00:31:12
lógicamente los más complicados 00:31:15
de resolver, es decir, jodid 00:31:17
Pero si es que yo creo que se hace así 00:31:18
Y lo ejecuto y no 00:31:20
O me sale un error 00:31:22
O a lo mejor no me sale error 00:31:23
Pero no hace lo que tiene que hacer 00:31:25
Le estoy diciendo que sume dos números 00:31:26
Le doy los dos números y nos está restando 00:31:29
Pues eso es un error de ejecución 00:31:31
¿Vale? 00:31:34
Bueno pues entendamos también 00:31:35
Ya esos términos desde ya 00:31:37
Error de compilación y de ejecución 00:31:39
Vale 00:31:41
Bueno y ya por último dentro de esta introducción 00:31:42
Que vamos a ver acabado justo 00:31:45
entonces, para nosotros 00:31:47
programar se va a traducir en 00:31:51
recibir 00:31:52
el enunciado de un problema 00:31:54
que tenemos que resolver 00:31:57
tenemos que resolver un problema 00:31:58
ahora, me pongo a 00:32:00
mover la cabeza, me pongo a 00:32:03
hacer mis ideas, ah pues mira, voy a coger 00:32:05
dos variables aquí 00:32:07
voy a hacer aquí un bucle que 00:32:08
me esté recorriendo de 1 a 10 00:32:11
a ver si hasta que encuentre no sé cuántos 00:32:13
yo me hago ahí mis ideas, no sé cuánto para ti 00:32:15
Una vez que ya tengo más o menos un boceto de lo que quiero hacer, ahora ya empieza un proceso, que es escribirlo en un editor de texto, escribirlo en el código fuente. 00:32:16
Intentar compilarlo o interpretarlo, depende del lenguaje en el que esté, para ver si compila o no compila, a ver si tiene errores de compilación o no los tiene. 00:32:30
si los tiene 00:32:39
los arreglo 00:32:42
si no los tiene, los lanzo a ejecutar 00:32:43
¿vale? si tiene errores de ejecución 00:32:46
pues puedo 00:32:49
entrar a depurar, es decir, hay muchas tareas 00:32:50
que nosotros podemos 00:32:52
hacer con las herramientas básicas del ordenador 00:32:54
con mi blog de notas 00:32:56
yo podría escribir mi programa 00:32:58
lanzar mi máquina virtual a mano 00:32:59
pum, lanzar la mano, decirle a mi máquina 00:33:02
virtual, coge este programa que he hecho con el blog 00:33:04
de notas, si me falla 00:33:06
me saldrá un error en la consola 00:33:08
y me iré a cambiarlo 00:33:10
pues sí, puedo programar así 00:33:12
pero hombre, como hay muchas tareas 00:33:14
que vamos a repetir todo el rato 00:33:16
nacen unos software 00:33:18
unos programas 00:33:21
que se llaman los entornos de desarrollo 00:33:22
¿vale? 00:33:25
¿vale? ¿qué es un entorno 00:33:33
de desarrollo? un entorno de desarrollo 00:33:35
es un software que está 00:33:37
pensado para ayudarte a 00:33:39
programar 00:33:41
entonces, integra 00:33:42
un editor de texto para que tú escribas 00:33:44
tu programa 00:33:46
integra herramientas 00:33:47
que rápidamente te avisan si has 00:33:51
escrito algo mal o no lo has escrito mal 00:33:52
integran herramientas 00:33:54
que te permiten automatizar 00:33:57
hacer más rápido tareas que si no 00:33:59
tendrías que hacer pues tú a mano 00:34:01
con el blog de notas que serían más pesadas 00:34:02
integran 00:34:04
que se lance el programa y no tienes tú 00:34:06
que llamar a la máquina virtual para decirle 00:34:08
oye, lanza este programa 00:34:11
se integran muchas de esas tareas, como iremos viendo. 00:34:12
¿Vale? Entonces, lógicamente, nosotros usaremos un entorno de desarrollo 00:34:15
para facilitar nuestra tarea de desarrollar software, para facilitarla. 00:34:19
En Java en particular, pues tenemos los tres más usados, ¿vale? 00:34:26
Entonces, este es de distribución gratuita y tiene, aparte de toda una trayectoria, 00:34:38
una implantación 00:34:45
en el mercado enorme 00:34:48
y es el que vamos a usar nosotros aquí en clase 00:34:48
si alguien quiere usar otro 00:34:52
que lo use, pero bueno 00:34:53
este sí que es de licencia de pago 00:34:54
y este 00:34:57
a ver, no os lo recomiendo 00:34:59
no porque nos viene muchísimo 00:35:02
de potencia como todos 00:35:04
pero se está empezando a usar menos 00:35:04
aunque hay muchísimas empresas que lo siguen usando 00:35:07
pero el NetBeans se está empezando a usar menos 00:35:09
entonces os recomiendo 00:35:12
para que uséis vosotros el que os dé la gana 00:35:14
aquí en clase, los exámenes 00:35:17
los exámenes los haremos con este 00:35:19
entonces tenéis que tener soltura con ese 00:35:21
porque si surge algo 00:35:23
en el eclipse y no me sale 00:35:25
yo asumo que vosotros ya lo sabéis usar 00:35:26
tal y como lo hayamos usado aquí 00:35:29
¿vale? 00:35:31
bueno, pues justo acabamos con esto 00:35:33
la introducción 00:35:35
¿vale? no olvidéis que el entorno de desarrollo 00:35:37
por mucho que tenga la IA integrada 00:35:39
que te dice lo que tienes que decir después 00:35:41
que lo explica y todas esas patatillas 00:35:43
¿vale? 00:35:45
no tiene que sustituir 00:35:47
porque si dejáis que os sustituya 00:35:49
no vais a aprender a programar 00:35:52
y si no aprendéis a programar, suspendéis 00:35:53
o lo que es peor, si no aprendéis a programar 00:35:55
ya robáis y luego 00:35:57
vais a lo que acaba de elaborar 00:35:58
y se acabó, ya estáis crucificados 00:36:01
¿vale? entonces cuidado con eso 00:36:03
venga, pues ahora ya 00:36:06
sí que sí, paramos 00:36:07
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
6
Fecha:
15 de septiembre de 2026 - 12:10
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
36′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
373.38 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid