Saltar navegación

Intro Prog 1 - 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 2025 por Stefano C.

46 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a que graben vuestro. 00:00:00
Primera clase, vamos a ver un poquito de introducción a la programación. 00:00:07
Primera cosa, ¿qué es la programación y qué es un programa? 00:00:18
Una definición así no formal, pero para que nos entendamos un poco. 00:00:21
La programación consiste en la creación de un conjunto concreto de instrucciones 00:00:26
que un ordenador puede interpretar denominado programa de ordenador vale entonces lo que vamos 00:00:29
a hacer nosotros es crear cosas y escribir un párrafo de código raro que sustancialmente es 00:00:34
una forma que tenemos para poder comunicar con nuestro ordenador y decirle que queremos que 00:00:43
haga el ordenador vale a partir de allí estas cosas que escribimos este lenguaje raro que 00:00:49
utilizamos es un programa el programa lo puede entender el ordenador y nosotros nos transformamos 00:00:55
sustancialmente en lingüistas en personas capaces de comunicar con un ordenador y decirle que 00:01:02
queremos crear si esto lo hacemos creando programas un programa se escribe normalmente en un lenguaje 00:01:10
de programación pero no necesariamente este lenguaje de programación es de alto nivel es 00:01:18
se puede llegar a hablar con un ordenador a nivel de ceros y unos vale tú puedes escribir un programa 00:01:24
con ceros y unos hoy en día eso no se hace porque es aburrido pero si habéis visto alguna película 00:01:36
vieja o cosas por el estilo había un tiempo los primeros ordenadores había una figura profesional 00:01:42
de una persona que el matemático físico o matemática física que hacía el algoritmo 00:01:48
lo escribía en un papel, se lo daba a esta persona que transfería en unas tarjetas perforadas 00:01:55
el algoritmo, el programa que el otro se había inventado. 00:02:03
Y, sustancialmente, las tarjetas perforadas eran ceros y unos. 00:02:10
O sea, la perforación es un cero, si no la perforación es un uno, o al revés. 00:02:13
entonces a esos tiempos se programaba en ceros y unos 00:02:16
y había alguien que decía 00:02:19
vale, tú quieres hacer esto 00:02:21
la máquina puede interpretar solo ceros y unos 00:02:22
y yo estoy en el medio 00:02:25
y lo que hago es transformar lo que tú has pensado 00:02:26
en un código de ceros y unos 00:02:29
con el pasar del tiempo 00:02:31
pues la cosa se ha ido hacia 00:02:33
mayores niveles de 00:02:34
abstracción hasta llegar a los 00:02:36
programas que tenemos 00:02:39
a los lenguajes de programación que tenemos nosotros 00:02:40
ahora más adelante veremos 00:02:42
cosillas de este estilo 00:02:44
¿Qué más? 00:02:46
Lenguaje de programación, aquí lo ven. 00:02:50
Son conjuntos de símbolos y palabras claves, palabras concretas, 00:02:52
que conforman una sintaxis y una forma de crear los comandos 00:02:57
para que, sustancialmente, yo, utilizando lo que tengo a disposición, 00:03:03
pueda elaborar un programa. 00:03:08
Entonces, yo antes tengo que saber cuáles son las palabras que puedo utilizar, 00:03:10
cómo se usan, en qué secuencia se pueden poner, 00:03:13
una vez que sé esto, que he aprendido la sintaxis de un lenguaje de programación, 00:03:17
pues he hecho la parte fácil, porque ahora lo que viene fuera 00:03:21
es el pensar cómo se resuelve el problema que quiero resolver. 00:03:25
Y eso es crear el algoritmo, que es la parte más compleja del programa. 00:03:30
Nosotros en el primer trimestre principalmente 00:03:35
nos centraremos en sintaxis, porque muchos de vosotros no han visto 00:03:38
nunca un lenguaje de programación, entonces esa 00:03:42
será la parte un poquito más compleja, entender 00:03:44
qué quiere, cómo se 00:03:46
puede mandar la 00:03:48
información al 00:03:50
generador 00:03:51
luego paso a paso eso se volverá 00:03:53
lo normal, el estándar 00:03:56
y nosotros nos empecemos a centrarnos 00:03:58
en proyectos un poquito más complejos, programas 00:04:00
un poquito más retorcidos, un poquito 00:04:02
más interesantes 00:04:04
también y más potentes 00:04:06
los lenguajes de programación 00:04:07
pueden ser 00:04:10
de distintos niveles de abstracción, digamos así. 00:04:12
El más bajo en absoluto sería programar 00:04:16
en ceros y unos. Ya no se programa en ceros y unos, lo hemos dicho. 00:04:18
El siguiente paso sería el lenguaje máquina. El lenguaje máquina 00:04:21
es como un lenguaje que 00:04:24
los procesadores puedan entender directamente. 00:04:26
Cada procesador tiene un conjunto de comandos 00:04:30
de muy bajo nivel que se podrían 00:04:33
escribir, entre comillas, directamente al procesador 00:04:36
para que él entienda que tiene que hacer y trabaje, ¿vale? 00:04:39
Normalmente, una parte de estos comandos son estándar, 00:04:44
pero hay otras partes que cada productor, 00:04:52
cada constructor, digamos, de procesadores, 00:04:55
tiene su propio lenguaje máquina dedicado, ¿vale? 00:05:01
Esto implicaría que si yo trabajo con un Intel de una cierta forma, 00:05:06
o trabajo con un AMD de otra forma, o trabajo con un Apple de otra forma, 00:05:10
pues debería conocer el lenguaje propio de ese procesador, ¿vale? 00:05:14
Cosa que sería muy compleja. 00:05:19
Un tempo se hacía así, pues ahora ya no, ¿vale? 00:05:21
Lo que yo quiero es abstraer de lo que tengo 00:05:24
y tener una forma de hacer cosas más abstractas, más a alto nivel, 00:05:27
y que luego estos programas que yo escribo a más alto nivel 00:05:32
se puedan ejecutar en procesadores distintos. 00:05:36
Para esto, el primer paso de abstracción es el Ensemblador o Assembler en inglés. 00:05:40
Esto es un pequeño lenguaje de programación 00:05:46
que en vez de programar en ceros y unos 00:05:48
y con comandos directamente del lenguaje máquina del propio procesador 00:05:52
me abstrae un poquito. 00:05:55
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. 00:05:59
Estoy siempre a muy bajo nivel, estoy trabajando con lo que son los registros de un procesador. 00:06:09
La memoria más a bajo nivel, más cercana al procesador, son los registros. 00:06:14
Son trocitos de memoria muy, muy, muy rápida, pero muy, muy, muy cara, que están directamente incrustados dentro de los procesadores. 00:06:19
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, 00:06:27
pero sigue siendo una cosa muy de bajo nivel, ¿vale? Eso no se suele ver, no se suele trabajar. 00:06:56
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 00:07:03
en una asignatura que se llama compiladores, pues probablemente tendréis que hacer algo con el sembrador, ¿vale? 00:07:11
Veremos ahora dentro de un rato qué es un compilador, ¿vale? 00:07:18
y entenderemos que es traducir el lenguaje de alto nivel, como Java o lo que sea, que utilizo yo, a un ensamblador. 00:07:21
Y luego el ensamblador tendrá un intérprete o algo por el estilo que transformará este lenguaje en lenguaje máquina 00:07:31
y entonces el procesador podrá ejecutar ese programa. 00:07:39
Pero a nosotros nos interesa el alto nivel, a nosotros nos interesa la abstracción. 00:07:44
en un cierto sentido la inteligencia artificial 00:07:48
misma es otro nivel de 00:07:51
extracción a nivel de programación 00:07:53
a nosotros nos gustaría programar 00:07:55
diciendo que era un programa que 00:07:57
calcula la suma de dos números 00:07:59
esto, así, en 00:08:01
lenguaje natural, y que el ordenador 00:08:03
lo entiende y diga, vale, muy bien, esto 00:08:05
ahora lo hago, que un poco 00:08:07
la inteligencia artificial está yendo hacia 00:08:09
esa posibilidad 00:08:11
eso sería un nivel de extracción 00:08:13
todavía más alto de lo que tenemos 00:08:15
nosotros. Cuando hablamos de alto nivel, nosotros hablamos de lenguajes como Java, como C, como 00:08:17
Python, como no lo sé, hay otros ejemplos por ahí, que me permiten describir lo que 00:08:23
tiene que hacer mi programa, ¿vale? Pero totalmente independiente de lo que tengo por 00:08:33
debajo a nivel de ordenador que tengo por debajo, ¿vale? Yo le explico que, oye, mira, 00:08:39
quiero que me escribas en pantalla esta cosa, para hacer esto tengo que ponerle un código, 00:08:45
un comando específico del lenguaje, pero luego ¿cómo se hace esto? O sea, todo el proceso de 00:08:51
que el procesador tiene que entenderlo, pillar los datos que yo quiero que se imprima en pantalla, 00:08:58
ir a hablar por la pantalla, decirle a la pantalla tienes que escribir esto, todo esto yo quiero que 00:09:02
esté escondido. Eso es bajo nivel. Yo quiero verlo desde arriba. Yo le digo escríbeme esto ¿cómo se 00:09:06
hace para escribir todo eso, pues es problema tuyo. Esto es programar en un 00:09:13
cierto sentido a alto nivel. Yo me voy a centrar principalmente en el algoritmo y 00:09:20
en una sintaxis mucho más parecida, mucho más vecina, cercana a la del lenguaje 00:09:25
natural y no quiero molestarme con todo lo que es por debajo de él. Vete a la 00:09:32
memoria a la RAM 00:09:39
vete a buscar en la RAM la celda 00:09:40
37, allí me pillas 00:09:43
ese dato, me lo escribes en un fichero 00:09:45
yo no quiero todas esas cosas, la cosa me la tiene que 00:09:46
hacer alguien por debajo, yo quiero 00:09:49
programar a un nivel más alto 00:09:50
¿se entiende más o menos? 00:09:52
nosotros trabajaremos con Java 00:09:54
que está aquí 00:09:56
entonces 00:09:58
hay lenguajes de programación 00:10:00
de alto nivel imperativos 00:10:03
¿vale? los imperativos 00:10:04
son sustancialmente 00:10:07
lenguajes que funcionan con que yo describo lo que quiere hacer mi 00:10:08
programa paso a paso. La forma de programar a nivel imperativo es hoy 00:10:15
ordenador haz esto, luego haz esto, luego haz esto y si sigues todos mis pasos 00:10:22
habrás cumplido el algoritmo que me hacía falta y al final tendrás un 00:10:28
Un resultado, ese resultado, impríbelo en pantalla, eso es lo que yo quiero. 00:10:33
¿Vale? 00:10:38
Es dar comandos. 00:10:39
Dar, haz esto, esto, esto, esto, en secuencia. 00:10:42
¿Sí? 00:10:44
Cuando estamos en un lenguaje de alto nivel, un comando solo, una línea de comando que vosotros pondréis diciendo, 00:10:48
hace esta cosa, en realidad 00:10:56
a bajo nivel 00:10:57
puede incluir 00:10:59
muchas instrucciones 00:11:01
máquinas. El 00:11:03
escríbeme esto en pantalla, que tú ves 00:11:05
escríbeme hola en pantalla, tú ves un programa 00:11:07
que te escribe hola y se acabó. 00:11:10
En realidad, por debajo, a nivel 00:11:12
de procesador, pues tendrá 00:11:14
mucho más pasos. 00:11:16
Pasos que pedirá la H. 00:11:18
La H tendrá un código, 00:11:20
la carga en un lado, luego pilla 00:11:21
la O, luego se 00:11:24
comunicará con la pantalla, le dirá, oye, mire, el driver de la pantalla tiene que escribir 00:11:26
este código que se refiere a una H, etc. Todos estos programas, 00:11:30
todos estos pasos, estarán a nivel bajo y nosotros no lo vemos. 00:11:34
Nosotros nos quedamos. 00:11:38
Lenguaje imperativo describe secuencias de operaciones a realizar para obtener un 00:11:42
resultado. Entonces se programa así, a nivel imperativo. 00:11:46
Mi algoritmo será una secuencia de pasos. 00:11:50
Yo tengo que dividir el problema 00:11:54
¿Cómo se calcula la área de un triángulo? 00:11:55
Pues, algoritmo 00:11:59
Pillo la base 00:12:00
La multiplico por la altura 00:12:02
La divido por 2 00:12:03
El resultado en primera del pantalla 00:12:05
Pues, te he dado 3 pasos 00:12:07
Pues, esos son los pasos que tienes que seguir para hacer 00:12:09
Para solucionar el problema 00:12:12
Calcular la área de un triángulo 00:12:13
¿Me entiendes? 00:12:15
Vale, entre los lenguajes de alto nivel 00:12:18
Siempre a nivel imperativo 00:12:21
¿Vale? 00:12:23
Tenemos programas, lenguajes no estructurados, ¿vale? Ya no se usan, pero algunos de vosotros 00:12:24
podrían haber oído alguna vez el BASIC, ¿vale? Estos son programas donde sustancialmente 00:12:31
la esencia, la unidad del programa es la línea de código, ¿vale? Esto es, bueno, años 80, 90, por ahí, 00:12:37
donde se programaba 00:12:48
programas sencillos 00:12:50
no se podía hacer programas complejos 00:12:53
y grandes 00:12:55
y con esta 00:12:55
con este tipo de lenguajes 00:12:58
era suficiente 00:13:03
teniendo en cuenta que 00:13:04
también en informática las cosas evolucionan 00:13:06
en base a la necesidad 00:13:09
si yo tengo cosas muy sencillas 00:13:10
pues pillaré una cosa sencilla y sigo adelante 00:13:12
en cuanto las cosas se complican y se vuelven más 00:13:14
difíciles, pues a lo mejor lo que tenía antes, las herramientas que tenía antes 00:13:17
no son suficientes, entonces necesito desarrollar algo más 00:13:21
algo quizás a un nivel un poquito más alto de extracción 00:13:25
para que sostancialmente sea más fácil centrarme en lo que ahora 00:13:29
es importante, no lo de antes. 00:13:33
Entonces, el BASIC se basaba sobre la línea de código y tenía 00:13:37
el infernal GOTU. El GOTU era un comando que me permitía 00:13:41
saltar donde sea dentro de mi programa. ¿Vale? Eso era infernal porque para programas muy pequeños 00:13:45
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, 00:13:53
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 00:14:00
pequeños más o menos ves dónde vas. Programas muy muy complejos, estos saltos que no son estructurados 00:14:06
se volvían a enfermar. Los equipos eran incapaces de mantener sus propios programas. 00:14:14
Hacías los programas, mientras que este equipo trabajaba, a lo mejor se entendía más o menos, 00:14:21
en cuanto el equipo se iba porque cambiaba de trabajo, se jubilaba o pasaba a otro proyecto, 00:14:27
alguien de fuera que llegaba a ver ese código no podía entender que se había hecho. 00:14:32
con el aumentar de la complejidad de los programas 00:14:38
pues llegaron a ser estructurados 00:14:43
como por ejemplo el lenguaje C 00:14:45
que a lo mejor conocéis 00:14:47
es como el abuelo de C++ 00:14:48
o Pascal 00:14:51
en estos de aquí la base, la unidad 00:14:53
no es tanto la línea de código 00:14:58
cuanto la función en los módulos 00:15:00
o funciones y proceduras 00:15:02
Sostancialmente se dan bloques de líneas de códigos 00:15:04
A las que se le da un nombre 00:15:09
Esta es una función que se llama calcular el triángulo 00:15:11
Donde dentro están todos los comandos para calcular el triángulo 00:15:17
Luego estará una función que es calcular el cuadrado 00:15:21
Donde estarán todas las funciones de calcular el cuadrado 00:15:24
Cuando ahora hago mi programa matemática 00:15:26
Que permite hacer muchas cosas 00:15:29
Entre ellas calcular el triángulo 00:15:31
de calcular la área del cuadrado, pues tengo una estructuración. 00:15:33
No tengo todo mezclado en líneas de códigos retorcidos entre ellos 00:15:38
y saltos por aquí y por allá. 00:15:43
Tengo todo lo que es calcular la área del triángulo 00:15:44
bien empaquetado en una función concreta. 00:15:47
Y el cuadrado en otra. 00:15:50
Y el círculo en otra. 00:15:52
Entonces, esto me permite hacer muchas cosas. 00:15:54
Primero, entender más programas complejos. 00:15:58
organizarlos mejor, segundo, poder compartir trabajo, ¿vale? 00:16:03
Porque yo puedo decir que yo hago el programa que gestionará todas estas funciones 00:16:11
y a un grupo de trabajo le doy la parte que se ocupe de todo el triángulo. 00:16:15
Vosotros vais a desarrollar todas las funciones relacionadas con el triángulo. 00:16:21
A otro grupo, todos los que son el cuadrado. 00:16:25
A otro grupo, todo el cubo. 00:16:28
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, 00:16:30
sino simplemente haré llamadas a las funciones cuando las necesitaré. 00:16:46
tengo que calcularla de un triángulo, llamaré la función calcularla de triángulo 00:16:50
que dentro tendrá el algoritmo, los procedimientos, los pasos para calcularla de 10. 00:16:54
¿Se entiende más o menos? 00:17:01
Aún así, no es tan fácil analizar y diseñar, ¿vale? 00:17:04
Es más fácil que si usas un estructurado, pero aún así se vuelve un poquito complejo 00:17:09
siempre cuando el problema escala, ¿vale? 00:17:16
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. 00:17:19
Entonces, cambiaron de paradigma hacia la orientación a objetos. 00:17:26
La orientación a objetos es como una estructuración de más alto nivel. 00:17:31
Entonces, lo que se hace cuando se orienta a objetos es construir, identificar clases. 00:17:37
Estas clases definen, modelizan una parte de mi programa 00:17:43
Por ejemplo, yo si tengo una escuela, tendré una clase que modeliza el alumno 00:17:52
Una clase que modeliza el aula 00:17:56
Una clase que modeliza el profesor 00:17:58
En cada una de estas clases pondré la información relacionada con ese propio agente 00:18:01
O sea, el alumno tendrá su nombre, tendrá su DNI, tendrá sus notas, por ejemplo 00:18:07
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. 00:18:12
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. 00:18:25
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. 00:18:43
el aula podría tener 00:19:04
la función limpiar aula 00:19:08
que se llama una vez al día 00:19:09
al final del... no sé si me explico 00:19:11
entonces 00:19:13
lo que se intenta hacer es 00:19:15
mejorar la capacidad 00:19:17
de diseño y reutilización del código 00:19:20
para que se puedan hacer 00:19:22
programas mucho más complejos 00:19:24
y sea más fácil organizarnos 00:19:26
y entender 00:19:28
qué se quiere hacer, la análisis 00:19:29
dividirla y organizar 00:19:32
las varias componentes del 00:19:34
programa y del 00:19:36
proceso para que funcione 00:19:38
y sobre todo si mañana 00:19:39
en vez de una escuela como la nuestra 00:19:41
hago otra escuela de otro tipo 00:19:43
pues toda la parte que 00:19:45
pueda reutilizar la pueda 00:19:48
ya utilizar en el nuevo proyecto 00:19:49
sin tener que volver a desarrollarla 00:19:52
desde cero. Eso me ahorra costes 00:19:54
me ahorra problemas, me ahorra 00:19:56
también en expertise porque 00:19:58
probablemente quien ha hecho este programa 00:20:00
ya ha aprendido el problema 00:20:01
y ha hecho un buen trabajo 00:20:03
entonces yo reutilizo su trabajo 00:20:05
sin tener que volver desde cero 00:20:07
a entender cuál es el problema 00:20:09
y hacer los errores 00:20:10
que a lo mejor él ya ha cometido y solucionado 00:20:13
dudas 00:20:15
existen pero 00:20:17
otros tipos de lenguaje de programaciones 00:20:22
que son los lenguajes de programaciones 00:20:25
declarativos 00:20:26
antes eran imperativos 00:20:27
ahora son declarativos 00:20:30
la diferencia es que en mente de imperativos 00:20:31
yo le digo, haz esto, haz esto, haz esto, y tendrás la solución. 00:20:34
O sea, le explico cómo quiero que se hagan los pasos para llegar a una solución. 00:20:38
En el declarativo, la idea es que yo describo lo que quiero como resultado. 00:20:43
No cómo se llega a ese resultado. 00:20:50
Te digo lo que yo quiero al final, y luego tú, de alguna forma, lo sacas. 00:20:52
En el imperativo te digo 00:20:59
Tú pillas 00:21:01
No es exactamente así 00:21:03
Pero tené entendido 00:21:06
Pilla la base, pilla la altura 00:21:07
La multiplicas entre ellos, divide por dos 00:21:09
Todos los pasos 00:21:11
Has obtenido el área del triángulo 00:21:12
En un declarativo 00:21:14
No es exactamente así, pero entendedme 00:21:16
Yo le diría 00:21:18
Quiero tener el área de un triángulo 00:21:19
Es sustancialmente lo que está aquí dentro 00:21:22
Digo un triángulo 00:21:24
Y digo aquí 00:21:26
¿vale? y él 00:21:27
mágicamente lo hace 00:21:28
¿vale? ahora, está claro que 00:21:31
hay campos 00:21:33
en el que el imperativo 00:21:35
es mucho más cómodo de utilizar 00:21:37
como por ejemplo calcularlo en un triángulo 00:21:39
y el declarativo es súper 00:21:41
complejo porque no lo entendería un 00:21:43
lo que acabo de decir 00:21:45
un ordenador no lo va a entender 00:21:46
pero hay otros campos donde va al revés 00:21:48
¿vale? un ejemplo 00:21:51
que a lo mejor algunos de vosotros 00:21:52
ha oído de 00:21:55
lenguaje declarativo es 00:21:56
SQL. 00:21:58
SQL es un lenguaje de consultas 00:22:00
para bases de datos. 00:22:03
Si vosotros habéis visto alguna vez en vuestra 00:22:05
vida una query SQL, 00:22:07
sustancialmente es, selecciona 00:22:09
los campos 00:22:11
nombre de una tabla 00:22:12
de alumnos ordenados 00:22:14
por 00:22:17
en orden alfabético. 00:22:17
Tú no estás diciendo 00:22:22
cómo hacer esas cosas. 00:22:23
Estás diciendo lo que quieres y al final quiero un listado de nombres de alumnos ordenados alfabéticamente. 00:22:24
Estoy describiendo el resultado. Luego, ¿cómo tú llegas a ese resultado? El problema es tuyo. 00:22:31
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. 00:22:37
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. 00:22:46
En imperativo estás describiendo los pasos para llegar a lo que tú quieres. 00:22:52
¿Se entiende la diferencia? 00:22:58
Vale. 00:23:00
Otros lenguajes declarativos son, por ejemplo, lisp o prolog. 00:23:01
Aquí siempre cuento mi experiencia personal. 00:23:06
Cuando en la prehistoria yo era estudiante de informática y vine aquí a la UPM, en Erasmus, 00:23:11
pues me pusieron junto con otra chica 00:23:18
a hacer un programa de elaboración 00:23:22
de lenguaje natural, ¿vale? 00:23:25
Entonces estábamos haciendo esta asignatura 00:23:26
nos dieron un ejercicio, no me acuerdo 00:23:28
pero tenías que analizar algunas palabras 00:23:31
sacar algunos patrones y cosas por el estilo. 00:23:35
Yo me puse a hacerlo en Java, ¿vale? 00:23:37
Me tiré un par de horas de Java 00:23:39
hice una cantidad de código así 00:23:41
¡pa, pa, pa! 00:23:44
Lancé el programa, funcionaba perfectamente. 00:23:45
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. 00:23:47
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. 00:24:01
solo que yo la programación declarativa a ese tiempo no sabía ni siquiera que existía 00:24:15
y por lo tanto ella sí 00:24:19
la idea es que uno es mejor uno es peor 00:24:21
depende del campo en el que estás trabajando 00:24:26
estos de aquí son programaciones lógicas y funcionales 00:24:30
utilizan funciones y funciones lógicas 00:24:34
de una forma mucho más dinámica 00:24:39
con respecto a lo que lo utiliza la programación imperativa, 00:24:43
nosotros emprenderemos programación imperativa, 00:24:47
que es lo más normal allí afuera. 00:24:50
Digamos que un 75% quizás de programas que se hacen allí afuera 00:24:54
para la empresa, para navegación, internet, cosas por el estilo, 00:24:59
son programación imperativa. 00:25:04
Estos entran más en cosas, por ejemplo, ahora con la inteligencia artificial, 00:25:06
ahora con algunos campos de procesamiento de vídeo de Maré, 00:25:10
pues estas cosas pueden salir porque permiten cosas que el lenguaje imperativo no permite. 00:25:17
Pero, por ejemplo, justo para eso, las últimas versiones, 00:25:24
y por último entiendo ya desde un rato, versiones de Java, 00:25:27
han empezado a construir la posibilidad de hacer pequeñas cosas declarativas 00:25:31
dentro de un marco imperativo hay algunas lo veremos algunas pinceladas más mucho más adelante 00:25:36
en el curso hay algunos comandos algunas sintaxis para que el lenguaje java que es imperativo se 00:25:47
porte más como declarativo en general por tiempo de entender algo de programación podemos pasar 00:25:56
como parámetro en vez que un dato, una función. Entonces, códigos. Este de aquí es cálculo de la 00:26:02
serie de Fibonacci. ¿Qué es la serie de Fibonacci? Es 1, 1 y luego el siguiente número es la suma de 00:26:17
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. 00:26:25
esa es la serie Fibonacci. Entonces tú puedes hacer un programita que dice 00:26:34
cálculame el veintisietésimo número de la serie Fibonacci. Este de aquí es 00:26:39
cómo saldría el cálculo del número n de la serie Fibonacci en Ensembler, 00:26:48
Assemblador. ¿Vale? ¿Lo explicáis? 00:26:54
Ah, tengo que recordar que el año pasado cuando hacía zoom, luego se veía mal en la grabación, 00:26:59
por lo tanto no lo hago, luego lo pruebo. Pero bueno, ¿cuánto lo tenéis allí? Si os fijáis, 00:27:13
estos comandos de aquí te están diciendo mueve el registro 0, mueve registro 1, mueve registro 2 00:27:20
dentro del registro 1, hace cosas 00:27:30
raras, ¿vale? pero esto es 00:27:32
un lenguaje de programación de lo que 00:27:34
hemos visto antes, no el lenguaje máquina 00:27:36
el siguiente nivel, el primer nivel de abstracción 00:27:38
esto sería como se hace el Fibonacci 00:27:40
en Semblador, ahora si yo lo 00:27:43
miro así, tengo una idea 00:27:46
es complejo de entender 00:27:48
entender y programar 00:27:49
en Semblador es complejo 00:27:52
porque no hay nada aquí que me hace 00:27:54
aparte de los comentarios que son las partes 00:27:56
en verde, si yo quitarlo a la parte 00:27:58
en verde, pues se entiende mal, no se entiende 00:28:00
ni siquiera lo que está haciendo. 00:28:02
Porque es de muy bajo nivel. 00:28:04
Entonces vamos a ver lo mismo 00:28:06
en C 00:28:08
o en Python. 00:28:09
Esto de aquí, hacen 00:28:12
lo mismo que antes, pero ves 00:28:14
ahora, por ejemplo, en C, yo tengo 00:28:16
comandos que son printf, 00:28:18
print, imprimir, 00:28:20
pues son cosas que me imprime estas 00:28:22
cosas en pantalla. Scan 00:28:24
es de leer, ¿vale? 00:28:26
Esto de aquí sirve para leer un número desde teclado. 00:28:28
Entonces, este de aquí, por, diga, hazme esto. 00:28:31
Son palabras, son formas de escribir que no es lenguaje natural, no es castellano, no es inglés, 00:28:36
pero se acerca un poquito, se entiende un poquito más. 00:28:44
Es más compacto porque cada una de estas instrucciones en realidad corresponderá 00:28:47
a varios bloques de programación en el sembrador. 00:28:53
pero esto ya lo entiendo un poquito más vale es de más alto nivel esto es python vale si os fijáis 00:28:58
no tiene nada que ver uno con otro vale son formas de escribir las cosas distintas tienen 00:29:07
la sintaxis distintas algunas cosas uno será más fácil algunas cosas más difíciles pero 00:29:14
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? 00:29:21
Entonces, probablemente, entender esto es mucho más fácil que otras cosas. 00:29:32
Esto es Fibonacci en Prologue en Lisp. 00:29:40
¿Veis? Es todavía más pequeño. 00:29:44
Aquí, para entenderlo de otro modo, te estoy diciendo que si buscas Fibonacci de 0, 00:29:48
o sea, el elemento 0 de Fibonacci, te doy 0. 00:29:55
Si buscas Fibonacci de 1, te doy 1, ¿vale? 00:29:58
Que son los dos casos bases. 00:30:03
Y a partir de aquí, si me das el número n, te devuelvo el número y. 00:30:05
¿Cómo está calculado el número y? 00:30:11
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. 00:30:13
Pero en vez de ir acumulando y cosas por el estilo, hace cosas. 00:30:34
Esta se llama recursividad, que es llamar la misma función de Fibonacci dentro de la definición. 00:30:38
son cosas más 00:30:44
complejas, sobre todo a este nivel 00:30:47
normal que no lo entendas 00:30:49
¿vale? 00:30:50
esto en vez de decir una función Fibonacci 00:30:52
que hace cosas raras 00:30:55
y cosas por el estilo, aquí también está 00:30:57
utilizando recursividad para poder hacer 00:30:58
¿sí? pues cada 00:31:01
uno tiene sus ventajas y sus 00:31:03
desventajas 00:31:05
entonces, resumiendo 00:31:06
hasta aquí, hay lenguajes de programación 00:31:08
a nosotros nos interesa el lenguaje de programación de alto 00:31:11
nivel, hay distintos tipos de lenguaje de programación de alto nivel, en particular 00:31:13
hay imperativos y declarativos. A nosotros nos interesan más los imperativos. Dentro 00:31:18
de los imperativos hay no estructurados, estructurados y orientados a objetos. A nosotros nos interesan 00:31:25
los orientados a objetos. ¿Estamos colocados más o menos en el sitio correcto? Siguiente 00:31:30
Este concepto, compilación e interpretación, para que un lenguaje de alto nivel funcione, yo tengo dos posibilidades. 00:31:38
O lo compilo o lo interpreto. Una de las dos opciones. 00:31:48
Esto siempre estamos hablando de lenguaje de alto nivel. 00:31:55
Si yo tengo un lenguaje como un lenguaje máquina que trabaja directamente con el procesador, 00:31:57
allí no hay interpretación 00:32:03
ni compilación 00:32:04
allí funciona directamente 00:32:07
pero si yo tengo un lenguaje de alto nivel 00:32:08
tengo esta cosa aquí 00:32:10
¿vale? 00:32:12
necesito que alguien transforme 00:32:15
esto 00:32:17
en ceros y unos 00:32:18
que el procesador pueda entender 00:32:20
¿vale? 00:32:23
el proceso 00:32:25
que pilla un lenguaje de programación 00:32:26
de alto nivel y lo 00:32:29
transforma en una secuencia 00:32:31
de ceros y unos, que serán comandos propios del procesador para que se puedan ejecutar 00:32:33
en el procesador, se llama o compilación, veremos ahora qué es exactamente, o interpretación. 00:32:39
Dependiendo de cómo hago este proceso, estoy compilando o estoy interpretando. 00:32:46
Entonces, ¿qué es un intérprete? Un intérprete es un programa que funciona por su cuenta. 00:32:53
alguien ya ha creado este programa y este programa está funcionando 00:33:00
al que yo le paso comando por comando 00:33:03
las líneas de mi programa, es decir 00:33:07
le paso primero esta línea de aquí, luego esta línea de aquí 00:33:11
luego esta línea de aquí, y el intérprete 00:33:16
recibe como input esta 00:33:19
línea de código, la transforma en ceros y unos 00:33:23
en varias operaciones de lenguaje máquina 00:33:28
que pueden ser interpretadas por el procesador 00:33:33
y se la da al procesador para que la ejecute. 00:33:40
Un intérprete es un programa que recibe en input, en entrada, 00:33:45
líneas de comando, líneas de código de un lenguaje de alto nivel 00:33:51
y lo traduce, lo interpreta en ceros y unos que son ejecutables por el procesador. 00:33:58
El intérprete es un programa, es algo que tiene que ser ejecutado, ¿vale? 00:34:09
Entonces alguien tiene que, antes de haber creado un programa de alguna forma, 00:34:15
haber creado los ceros y unos interpretables por un procesador 00:34:20
y decir, ok, procesador, empieza a trabajar con este programa. 00:34:23
Ahora yo tengo un proceso que está en ejecución 00:34:26
En el procesador 00:34:29
Está funcionando 00:34:31
Y empieza a decirle, haz esta cosa 00:34:32
En lenguaje a alto nivel 00:34:35
Y él lo traduce en 0x1 y se lo ejecuta 00:34:36
Ahora haz esta cosa 00:34:38
Y él 0x1 y se lo ejecuta 00:34:40
Haz esta otra, etc, etc 00:34:41
¿Entienden un intérprete? 00:34:43
Vale 00:34:46
¿Qué es en vez de un compilador? 00:34:46
Un compilador es otro programita 00:34:49
Que pero 00:34:51
Lo que hace es pillar todo el código de alto nivel 00:34:52
De golpe 00:34:56
yo le paso el programa entero él lo analiza lo machaca entero todas las líneas y a partir del 00:34:56
programa que le he dado yo genera una versión que hace lo mismo pero todos en ceros y uno 00:35:06
mientras el intérprete pillaba una línea y la traduce y ya trae línea en la traduce linterna 00:35:15
El compilador pilla el programa entero y me da como output otro programa entero, pero escrito en ceros y unos. 00:35:22
Lo que se llama un ejecutable. 00:35:30
Lo que vosotros habéis visto alguna vez en vuestra vida como .exe. 00:35:32
Un .exe, sustancialmente, es un programa compilado. 00:35:37
Había alguien escrito un programa en algún lenguaje de programación, le ha dado al compilador, 00:35:43
El compilador ha sacado este fichero 00:35:49
Lo llamamos .exe 00:35:51
Y es ejecutable 00:35:53
Porque si yo le doy doble clic 00:35:54
El procesador leerá esos ceros y unos 00:35:55
Y como son lenguaje máquina 00:35:58
Lo puedes ejecutar directamente 00:36:00
¿Entiendes? 00:36:02
Proceso de compilación 00:36:12
Yo tengo un programa en C 00:36:13
Por ejemplo, esto es basado sobre C 00:36:15
Porque típicamente C es un lenguaje de programación compilado 00:36:17
Por lo tanto, cuando vosotros escribís un programa en C 00:36:22
luego tenéis que hacer estos dos pasos, este otro, para que funcione este 00:36:25
vuestro programa. Entonces vosotros tenéis el lenguaje básico, el lenguaje de alto nivel C, 00:36:32
tenéis vuestro programa, llamáis uno programa que viene con la suite de programas para hacer 00:36:40
funcionar C, es algo que no tenéis que crear vosotros, os lo dan bajándolo de internet desde 00:36:47
algún sitio donde se desarrollan este tipo de cosas este programa aquí recibe vuestro 00:36:53
código en c como input y lo que hace es compilarlo transformándolo en ceros y unos 00:37:02
ahora cuando nosotros por ejemplo aquí utilizamos 30 este 30 nos descubriremos 00:37:12
dentro de un dato, es una función 00:37:22
¿vale? eso, ¿os acordáis 00:37:24
estos bloques de programación estructurada 00:37:26
que yo decía, calcular 00:37:28
el triángulo, y dentro ponía 00:37:30
como se ha calculado el triángulo, pues esta 00:37:32
es la función, printf 00:37:34
que lo que hace es recibir 00:37:36
estas palabras 00:37:37
como parámetro, y lo que 00:37:40
hace es escribirlo en la pantalla 00:37:42
ahora, ¿dónde está el código 00:37:44
de esta printf? 00:37:46
¿dónde está escrito 00:37:49
los comandos que se tienen que ejecutar 00:37:50
para que se imprima esto 00:37:53
en pantalla 00:37:55
aquí no está 00:37:55
y yo no quiero 00:37:58
cada vez que hago un programa 00:38:01
básico que tiene que escribir 00:38:02
hola mundo en pantalla 00:38:04
tener que implementarme como 00:38:06
se me interfazó, como lo leo 00:38:08
desde la memoria, como voy a la 00:38:10
pantalla, como pido al sistema 00:38:12
operativo que escriba en pantalla, como va 00:38:14
el sistema operativo al driver, todas estas cosas 00:38:16
yo quiero que me las den ya hechas 00:38:18
y me la dan ya hecha, es la print test 00:38:20
no la he desarrollado yo 00:38:22
está en una librería 00:38:23
de funciones 00:38:26
que C 00:38:28
o Java o C++ 00:38:29
me dan a disposición y que yo puedo utilizar 00:38:31
¿vale? ahora 00:38:34
en la primera 00:38:35
fase de compilación 00:38:38
lo que se hace es pillar mi 00:38:39
programa y transformarlos 00:38:42
en ceros y unos, lo que he hecho yo 00:38:44
pero claramente 00:38:46
Y de allí habrá algunas funciones que yo he utilizado como la printrc que no he hecho. 00:38:48
Entonces no la puede transformar en 081. 00:38:54
Necesita lo que hemos dicho, estas librerías, este conjunto de datos que ya alguien más 00:38:57
ha hecho y que no quiero hacer yo, donde estará escrito cómo funciona la printrc. 00:39:03
Pues esto es aquí. 00:39:08
Las librerías que usa mi programa. 00:39:12
En la primera fase compilo mi programa y después enlazo aquellas funciones que mi programa 00:39:15
usa que Perón no he hecho yo, que me ha dado ya a disposición el lenguaje de programación, 00:39:23
por ejemplo C, que me da a disposición la Printerz. 00:39:30
En la compilación se hacen dos pasos, compilo lo que tengo y le añado las funciones que 00:39:34
he usado que Perón no son mías. 00:39:42
enlazo las librerías que alguien más ha hecho para que complete los huecos que he dejado yo. 00:39:45
Porque yo aquí sustancialmente he dicho, oye, escríbeme en pantalla esta cosa, 00:39:52
pero no le he dicho cómo, entonces él dejará un hueco diciendo, 00:39:57
pues luego ya aquí en este hueco pondré la implementación de esta printf. 00:40:01
Alguien me dirá que la printf tiene que hacer estos comandos y yo los copiaré aquí. 00:40:05
Esto se hace en la fase de enlazado 00:40:10
¿Entiende? 00:40:13
Entonces 00:40:16
La compilación es esto 00:40:17
Tengo mi lenguaje de alto nivel 00:40:20
Compilo lo que puedo compilar 00:40:22
Que he escrito yo 00:40:24
Relleno las funciones 00:40:24
De terceros que he utilizado 00:40:27
En mi programa 00:40:30
Y a este punto tengo 00:40:30
Mi ejecutable 00:40:32
Un programa de ceros y unos 00:40:35
Que se puede ejecutar 00:40:37
en un cierto Windows 00:40:39
con un cierto procesador 00:40:40
porque el lenguaje máquina 00:40:42
depende de un procesador, depende del entorno 00:40:46
donde lo ejecuto, no es lo mismo 00:40:48
compilar para 00:40:50
Windows que compilar 00:40:52
para Macintosh 00:40:54
que compilar para Linux 00:40:56
o para 00:40:58
AMD que para Intel 00:41:00
por eso que, porque no se puede 00:41:01
ahora ya vamos más, pero porque no se 00:41:04
todos los juegos que hay en PC 00:41:06
no se pueden jugar en 00:41:08
en Apple, en Mac 00:41:09
porque no están compilados 00:41:11
¿vale? 00:41:14
y compilar 00:41:16
en otro sistema puede dar problemas 00:41:18
y no hay inversión suficiente 00:41:19
para decir no lo quiero compilar 00:41:21
también para la otra cosa ¿vale? porque no hay 00:41:23
juegos en Linux o hay muy pocos juegos 00:41:25
en Linux porque la gente, la mayoría 00:41:27
tiene Windows en casa y 00:41:29
tener el esfuerzo de hacer 00:41:31
compilaciones que funcionan y 00:41:33
debugging, o sea, quitar los errores 00:41:35
también en Linux para 00:41:37
los 3% de usuarios 00:41:39
que tienen Linux y que juegan 00:41:42
en Linux, pues no compensa. 00:41:43
¿Entiendes? Pues 00:41:47
esta es la compilación. 00:41:50
Entonces, 00:41:53
en la primera fase, 00:41:54
se pilla el programa fuente, 00:41:57
lo que he escrito yo en código, y se 00:41:58
transforma en un programa objeto 00:42:00
que es como 00:42:02
una 00:42:03
nueva versión del mismo 00:42:05
programa, pero escrito en otro lenguaje. 00:42:08
Esto está escrito en C, 00:42:11
esto está escrito en 00:42:12
lenguaje mágico 00:42:14
y después 00:42:16
con el código objeto 00:42:18
y las librerías que son 00:42:20
toda esta información adicional 00:42:22
que viene cuando yo programo en C 00:42:24
me instalo el kit para programar 00:42:26
en C o cuando por ejemplo 00:42:29
trabajo en Java, me instalaré 00:42:30
el JDK, el Java Development Kit 00:42:32
¿vale? aun si Java es un poquito distinto 00:42:35
ya lo veremos 00:42:37
pues sumando estas dos cosas 00:42:37
obtengo mi programa ejecutado este de aquí ya lo puedo llevar a mi ordenador a hacer doble clic y 00:42:40
se ejecutará y funcionará mi programa si lo lleva a otro ordenador con características similares 00:42:46
también me funciona lo llevo un ordenador con otro sistema operativo o con otro hardware 00:42:52
completamente el posible entre los dobles que no me funciona si dudas el intérprete 00:42:58
vez analiza el programa fuente y lo ejecuta directamente. Va línea por línea. Facilita 00:43:10
la búsqueda de errores ya que un programa puede interrumpirse en cada momento. Una cosa 00:43:19
interesante del intérprete es que yo digo ejecútame esto, vale, ejecútame esto, vale, ejecútame esto y ahora 00:43:24
cuando llegas aquí déjame ver qué está pasando. Como él ejecuta de uno en uno pues es mucho más 00:43:30
fácil. En un compilador no, porque el compilador ya está todo compilado y ejecuta de golpe. 00:43:36
Se puede modificar sobre la marcha. Hay intérprete que me permite, mira esto está 00:43:40
funcionando mal, espera un momento, cambio el código y como él va interpretando de uno en uno, 00:43:48
pues al añadirle un código adentro o en un bucle cambiándole algo, pues la siguiente vez que pasa 00:43:53
por allí, pues ejecutará una cosa distinta. Y es menos eficiente porque es un programa compilado. 00:44:00
porque claro, si yo compilo 00:44:05
ya tengo todo hecho, es solo ejecutar 00:44:08
lo que está allí, puedo ir del tirón rápido 00:44:10
esto por cada línea 00:44:12
de programa tendrá que hacer una serie 00:44:14
de ejecuciones que son 00:44:16
voy a mirar que quieres hacer 00:44:17
lo voy a traducir en lenguaje máquina 00:44:20
lo ejecuto, vale, ahora otro 00:44:22
son pasos más lejos 00:44:24
aquí está la comparación 00:44:29
entre compilador e intérprete 00:44:32
que veremos mañana 00:44:34
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
46
Fecha:
16 de septiembre de 2025 - 13:04
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
44′ 39″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
374.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid