Saltar navegación

240917 intro2 - 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 17 de septiembre de 2024 por Stefano C.

21 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta segunda parte, ¿vale? 00:00:00
Entonces, si habláis, me dais el consentimiento de grabaros. 00:00:04
Esto lo diré cada vez que grabo, ¿eh? 00:00:07
Para que quede grabado y no podáis pillarme en el juzgado. 00:00:09
Eso es. 00:00:15
Entonces, hemos visto distintos tipos de lenguajes, no los hemos entendido, 00:00:17
pues que no los conocemos, pero la idea es que el mismo programa aparece de formas distintas. 00:00:22
Teniendo en cuenta que esta es una cosa que viene por ahí en la teoría de la informática 00:00:27
Todos los lenguajes que hemos visto ahora pueden hacer sustancialmente lo mismo 00:00:32
Yo puedo hacer un programa en C++ o un programa en Java 00:00:37
Y que hagan exactamente lo mismo 00:00:43
Lo que pasa es que a lo mejor en uno sufro más que en otro 00:00:45
En uno me requiere más código que en otro 00:00:50
En otro una parte ya está desarrollada, la puedo reutilizar 00:00:53
Y en el otro en vez me tengo que escribir todo yo 00:00:56
O sea, puede haber diferencias de ese estilo 00:00:59
Pero a nivel de potencia de los lenguajes 00:01:02
Son todos equivalentes 00:01:05
¿Sí? 00:01:07
Entonces, dentro de este mundo de la programación 00:01:10
De los lenguajes programaciones 00:01:14
Encontramos dos métodos 00:01:15
Para que un lenguaje de alto nivel 00:01:20
Sea entendido por el procesador 00:01:23
Hemos dicho que el procesador 00:01:26
Solo entiende ceros y unos 00:01:28
Y nosotros no estamos escribiendo ceros y unos 00:01:30
Estamos escribiendo palabras y cosas por el estilo 00:01:34
Estamos escribiendo printf para que tú escribas en pantalla 00:01:36
O scanf para que tú leas un dato 00:01:39
Que te mando yo por teclado 00:01:43
El procesador esta cosa no la entiende 00:01:44
Necesito un mecanismo que pille mi alto nivel 00:01:47
Porque yo como programador quiero trabajar a alto nivel 00:01:52
De hecho, lo que decíamos antes 00:01:55
Mi sueño como programador 00:01:57
Es que yo ni siquiera necesite saber el lenguaje de programación 00:01:59
Que yo hable en lenguaje natural al ordenador 00:02:03
Le explique, mira, quiero una función 00:02:08
Que pilla dos números 00:02:09
El siguiente número es la suma de los dos anteriores 00:02:11
Y así cada vez 00:02:14
Y yo te digo el número que quiero 00:02:15
Y tú me dices, me haces los cálculos 00:02:17
Y que él me saque los ceros y unos suficientes 00:02:20
Para que se ejecute 00:02:23
Ese es el sueño 00:02:24
Que todos seamos programadores 00:02:26
Y que podamos hablar directamente con el ordenador 00:02:27
Unos 10 años 00:02:30
Lo está ya haciendo 00:02:32
El problema es que muchas veces se equivoca 00:02:35
Entonces todavía no estamos allí 00:02:37
Todavía a veces tú le dices una cosa 00:02:40
Y él hace lo que le da la gana 00:02:42
Diciendo es esta la solución 00:02:43
Y luego no es la solución 00:02:45
Cuanto más sencillo sí 00:02:46
Pero si te metes a hacer un programa muy complejo 00:02:47
no lo aguanta 00:02:49
¿vale? entonces 00:02:52
¿cómo se puede hacer esta traducción de 00:02:53
he escrito un programa de alto nivel 00:02:56
porque yo soy un programador y quiero escribir 00:02:57
a alto nivel porque me quiero olvidar 00:02:59
de los detalles de 00:03:01
oye, esta operación la podría utilizar 00:03:03
en este procesador o no, yo quiero escribir 00:03:05
pero escribo en pantalla 00:03:08
y luego ¿qué se ocupe? 00:03:09
necesito este mecanismo que pille este alto nivel 00:03:11
y lo transforme en ceros y unos 00:03:14
y que sean ceros y unos 00:03:16
que se puedan ejecutar en este ordenador 00:03:18
Y que este ordenador diga, vale, lo entiendo 00:03:19
Y me haga lo que yo le he pedido 00:03:21
Y hay sustancialmente 00:03:23
Dos formas de hacer esto 00:03:26
La compilación 00:03:28
Y la interpretación 00:03:30
¿Vale? 00:03:31
Cuando se habla de interpretación 00:03:34
Se necesita 00:03:36
Otro programita 00:03:38
Este otro programita se llama intérprete 00:03:39
Alguien 00:03:42
Se ha pasado la vida 00:03:43
A escribir un programa 00:03:45
Que lee código de alto nivel 00:03:47
Lee Java 00:03:51
Y lo transforma 00:03:52
En los equivalentes 00:03:55
Ceros y unos 00:03:56
Del procesador que está en su ordenador 00:03:57
Este programa 00:04:00
Se arranca 00:04:02
Está allí 00:04:03
Y lo que pasa es que 00:04:05
Tú le dices 00:04:07
Oye mira, intérpretame este programa de aquí 00:04:09
Que es el programa que has escrito tú 00:04:12
Y él se va a leer ese fichero 00:04:14
Pilla instrucción por instrucción 00:04:16
Y la interpreta con las correspondientes instrucciones a nivel máquina 00:04:19
Que tiene que hacer el procesador para poder hacer esa instrucción de código 00:04:27
Cuidado, no es que cada instrucción de alto nivel corresponde a una instrucción del procesador 00:04:31
A lo mejor una sola línea de código tuya se interpreta con 50 instrucciones del procesador 00:04:38
Pero yo no lo sé 00:04:47
Yo tengo este intermediario, esta persona en el medio, este programita que se llama el intérprete 00:04:48
Que sostancialmente puede leer un programa escrito en un lenguaje de más alto nivel 00:04:55
Interpretar lo que quiere decir 00:05:01
Y ejecutarlo materialmente dentro del procesador 00:05:04
Tienen en cuenta también que el intérprete tiene que estar arrancado 00:05:09
Tiene que funcionar 00:05:13
Si yo no lanzo este programa no me va a funcionar 00:05:14
No hay nadie que hace esta traducción 00:05:18
Y que el intérprete suele traducir línea por línea 00:05:20
Instrucción por instrucción 00:05:26
Pilla una instrucción, la interpreta, la ejecuta 00:05:27
pilla otra instrucción 00:05:30
la interpreta y la ejecuta 00:05:31
¿sabes de Java? 00:05:33
¿sabes que es la Java Virtual Machine? 00:05:40
ese es el intérprete de Java 00:05:42
Java Virtual Machine 00:05:43
lo veremos en Java 00:05:45
hay un programa 00:05:51
tú cuando instalas Java 00:05:53
cuando quieres usar Java 00:05:56
necesitas instalar una parte 00:05:58
que se llama el JRE 00:06:00
el Java Runtime 00:06:02
que sostantivamente te lanza 00:06:03
lo que es la Java Virtual Machine 00:06:08
La Java Virtual Machine es un programita que se ejecuta 00:06:09
Y que es el intérprete de Java 00:06:12
Entonces luego 00:06:14
La Java Virtual Machine lo que hace es interpretar 00:06:16
Tu código Java 00:06:18
Ahora veremos que es de verdad 00:06:19
Y lo interpreta 00:06:22
Si tú no tienes instalado en tu ordenador 00:06:23
La Java Virtual Machine 00:06:27
El JRL, Java Runtime and Verbal 00:06:28
No puedes ejecutar Java 00:06:30
El entorno de desarrollo 00:06:32
Puede ser cualquier cosa 00:06:39
Hasta el bloque de notas 00:06:40
Pero cuando tú has escrito el código 00:06:42
Le tienes que hacer algo 00:06:45
Ahora lo veremos en Java Studio 00:06:48
Porque imaginamos que sea interpretado puro 00:06:49
Pues tú este aquí lo guardas en un fichero 00:06:53
Y ahora llamas a otro programa 00:06:55
Que lo que va a hacer es leerte el fichero 00:06:57
Y traducirlo 00:06:59
Pero este programa aquí 00:07:01
El intérprete no lo hace 00:07:02
El intérprete que viene dado 00:07:04
Por quien desarrolla el programa 00:07:06
El intérprete podría ser 00:07:08
que tenga varios pasos 00:07:17
y que intérprete 00:07:20
traduca cada 00:07:21
instrucción 00:07:22
de alto nivel 00:07:25
la transforme en 00:07:26
ensemblador y que luego haya 00:07:28
un ejecutor 00:07:30
alguien que pueda ejecutar 00:07:31
el ensemblador más a bajo nivel 00:07:34
puede ser en dos pasos, puede ser en tres, puede ser en cinco 00:07:36
eso sí que se puede hacer 00:07:38
pero en principio tú podrías hacer 00:07:40
un programa, porque alguien lo ha desarrollado 00:07:43
quien desarrolla ese intérprete 00:07:45
Podría hacerlo que directamente lo pase 00:07:46
En ceros y unos 00:07:48
Y que se ejecutaría directamente el lenguaje max 00:07:50
Depende también de la eficiencia que buscas 00:07:53
De lo que estás buscando 00:07:57
Pero aquí hay un intérprete 00:07:58
Hay un programa extra 00:08:03
Que podéis desarrollar vosotros, sin duda 00:08:04
Que no soléis desarrollar vosotros 00:08:07
Que ha desarrollado alguien 00:08:09
Que ya me lo ha dado hecho 00:08:10
Ha dicho, si quieres usar mi lenguaje de programación 00:08:12
Este es el intérprete 00:08:14
Python creo que hace lo mismo 00:08:15
¿Vale? 00:08:17
Tienes que instalar Python para que luego funcione Python 00:08:17
Si no tienes instalado Python 00:08:21
No tienes el intérprete de Python 00:08:23
No te va a funcionar 00:08:24
Y este programita que se ejecuta 00:08:25
Cuando tú quieres ejecutar tu programa 00:08:29
Lo que hace es ir a leerse 00:08:32
Línea por línea tu programa 00:08:35
Y por cada línea la traduce y la ejecuta 00:08:36
Línea, traduce, ejecuta 00:08:38
Ese es como funciona un intérprete 00:08:39
La otra opción es la compilación 00:08:41
La compilación es, dame tu código fuente, lo que tú has escrito 00:08:45
Yo voy con otro programa, al principio de una sola vez 00:08:50
A analizar todo tu código y lo voy a traducir al lenguaje máquina 00:08:57
Y esta traducción al lenguaje máquina la guardo en un fichero 00:09:04
Una vez que he hecho este proceso 00:09:08
He traducido todo tu lenguaje 00:09:12
Todo tu programa 00:09:15
En lenguaje máquina 00:09:16
El compilador se acaba 00:09:17
No hago nada más 00:09:20
Ya no funciona 00:09:22
Ya no tengo que lanzar otra vez el compilador 00:09:23
Ya está compilado 00:09:26
Y ahora tú puedes 00:09:27
Ejecutar el programa objeto 00:09:30
La cosa final que has creado 00:09:33
Y este de aquí 00:09:35
Es un fichero 00:09:36
Ejecutable 00:09:38
Haces doble clic sobre ello 00:09:39
Y el procesador 00:09:42
Tiene dentro ceros y unos 00:09:43
Y puede entender como se ejecuta 00:09:45
El intérprete 00:09:48
Lo hacía línea por línea 00:09:51
Y tiene que estar activo 00:09:53
El intérprete 00:09:56
Mientras está ejecutando tu programa 00:09:57
Si lo lanzo otra vez 00:10:00
Tu programa 00:10:02
El intérprete tiene que seguir allí 00:10:02
Si el intérprete se para 00:10:04
No funciona 00:10:06
El compilador 00:10:07
Lanzo el compilador una vez 00:10:10
Hago la traducción 00:10:12
Y una vez traducido 00:10:14
El compilador no lo tengo que tocar nunca jamás 00:10:15
Tengo mi código ejecutable 00:10:19
Y para ejecutar ese código 00:10:21
Puedo ejecutarlo directamente 00:10:23
El ordenador lo entiende 00:10:25
Porque dentro lo he escrito en ceros y unos 00:10:27
Es una versión de lo que has escrito tú 00:10:29
Pero ha escrito en lenguaje Mac 00:10:31
¿Se entiende la diferencia? 00:10:33
Claro que si yo hago ahora una modificación 00:10:37
En mi código fuente 00:10:39
Tendré que lanzar otra vez el compilador 00:10:41
Para que cree una nueva 00:10:44
La versión ejecutable 00:10:46
De lo que 00:10:48
De lo que he escrito 00:10:50
De la nuevo programa que he hecho yo 00:10:51
Porque he cambiado algo 00:10:52
Y a este punto tendré el ejecutable 00:10:53
¿Habéis visto alguna vez un fichero .exe? 00:10:56
Esos son ficheros compilados 00:11:00
¿Sí? 00:11:01
Son ejecutables 00:11:03
Cuando vosotros tenéis un programita 00:11:04
Le pasáis el compilador 00:11:08
Este de aquí crea un fichero ejecutable 00:11:09
Que podría ser un .exe 00:11:12
Y a este punto vosotros tenéis el fichero allí 00:11:14
Le hacéis doble clic y esto ejecuta 00:11:16
Directamente 00:11:18
Se ejecuta el programa 00:11:19
Vamos a verlo 00:11:20
Más en detalle 00:11:26
Por ejemplo 00:11:28
C++ 00:11:30
Son programas compilados 00:11:31
Son lenguajes programaciones compilados 00:11:34
¿Qué quiere decir esto? 00:11:36
Que yo escribo un código fuente 00:11:37
Una vez que he escrito el código fuente 00:11:40
Tengo que hacer una compilación 00:11:43
¿Vale? 00:11:46
Con este programita aquí 00:11:47
Este programita aquí 00:11:48
Que viene en el pack de las cosas de CE 00:11:50
Por ejemplo 00:11:53
Lo que hace es pillarme un código fuente 00:11:53
Y traducirlo al lenguaje máquina 00:11:56
Y lo mete en un fichero 00:11:59
¿Sí? 00:12:02
Ahora, en este fichero de aquí, algunas cosas están escritas directamente. 00:12:04
Otras cosas, ¿vale? 00:12:13
No las puede escribir directamente. 00:12:15
Por ejemplo, escribir en pantalla. 00:12:18
Cuando yo escribo en pantalla, printf, ¿vale? 00:12:22
El comando a alto nivel es ese ahí, printf de hola. 00:12:26
Fenomenal. 00:12:30
Pero cuando luego quiero hacer un ejecutable, ¿cómo se hacen las operaciones para escribir en pantalla? 00:12:31
Dependen del ordenador en el que estoy. 00:12:41
No es lo mismo escribir en pantalla en un ordenador con procesador Intel y sistema operativo Windows, 00:12:44
Que en un ordenador que tiene un procesador AMD 00:12:55
Y que tiene instalado Linux 00:13:00
O que tiene un Mac y que tiene OSX 00:13:02
Cada uno de estos sistemas operativos 00:13:07
El sistema operativo, lo que tenéis en Windows, Linux y cosas por el estilo 00:13:10
Es una capa de abstracción entre usuario y hardware 00:13:13
Me permite usar un ordenador sin saber si aquí dentro hay un disco duro 00:13:19
Dos discos duros, si el disco duro es 00:13:24
Disco rotante 00:13:26
Si es con un SSD 00:13:28
Si es cuanta RAM tengo 00:13:30
Pues tengo todo escondido detrás del 00:13:32
Del sistema operativo 00:13:34
Yo le digo, crea un fichero 00:13:36
Donde se crea y como se crea 00:13:38
No tengo ni idea 00:13:40
Pero cuando yo le digo, crea un fichero 00:13:41
El sistema operativo va a hablar con el disco duro 00:13:44
Le dice, vaya disco duro, empieza a rotar 00:13:46
Asumiendo que sea un disco de los 10 00:13:48
Empieza a rotar 00:13:50
Cuando has llegado a esta velocidad de rotación 00:13:51
Mueve la cabecera a este sector 00:13:55
Cuando pasa por debajo 00:13:57
Este sector que yo he marcado que está libre 00:13:59
Empieza a escribir 00:14:01
Esto 0101110 00:14:02
Y todo esto 00:14:04
Es distinto si es un Windows 00:14:06
Que si es un Linux 00:14:08
Que si es un 00:14:10
Mac OS, que si es un Android 00:14:11
Que si es un 00:14:14
¿Se entiende esto? 00:14:15
Ahora, cuando yo aquí en mi 00:14:18
programa, le he dicho, escribe en pantalla 00:14:20
¿vale? 00:14:22
y él dice, vale, muy bien, entiendo 00:14:23
que aquí tengo que imprimir en pantalla 00:14:26
pero la operación de imprimir en pantalla 00:14:28
real 00:14:30
está en algún lado 00:14:31
en una librería 00:14:34
en una colección de funciones 00:14:36
proporcionadas 00:14:39
por el propio sistema operativo 00:14:40
entonces, Windows 00:14:42
proporcionará una serie 00:14:44
de funciones para escribir en pantalla 00:14:46
Funciones distintas de Linux 00:14:48
Que tendrá otras funciones para escribir en pantalla 00:14:50
Distintas de Android 00:14:53
Que tendrá otras funciones para escribir en pantalla 00:14:55
Y yo no sé cuáles 00:14:57
Hasta que llegue a esta fase de aquí 00:15:00
He hecho una primera traducción de lo que podía 00:15:03
De tu lenguaje 00:15:07
Al lenguaje mágico 00:15:09
Y todo lo que no he podido hacer aquí 00:15:10
Porque son cosas que dependen del sistema en el que estoy 00:15:12
Lo hago en una segunda parte 00:15:16
Que se llama enlazado 00:15:18
Aquí yo he dejado 00:15:20
Algunas partes vacías 00:15:22
Diciendo, aquí tendrás que poner el código 00:15:24
Que me permite escribir en pantalla 00:15:26
Aquí me tendrás que poner el código 00:15:28
Que me permite recibir teclas 00:15:30
Desde teclado 00:15:32
Aquí tendrás que poner el código 00:15:33
Para poder acceder a un fichero 00:15:36
De un disco duro 00:15:39
Y ahora 00:15:40
Huecos aquí 00:15:42
En esta segunda parte, que es el enlazado, el compilador va a buscar aquellos trozos de códigos referidos a un determinado sistema operativo con un determinado procesador 00:15:44
Y rellenará estos agujeros 00:16:05
Con los códigos 00:16:08
A nivel de lenguaje a máquina 00:16:11
Correcto 00:16:13
Correcto 00:16:14
Para este sistema 00:16:16
¿Me seguís? 00:16:18
Entonces 00:16:23
Tenía mi lenguaje 00:16:24
Mi programa que he escrito yo 00:16:26
Traduzco lo que puedo 00:16:28
Le añado, le enlazo 00:16:31
Las librerías dependientes del sistema 00:16:33
Y a este punto 00:16:35
Yo tengo un ejecutable. 00:16:37
¿Un ejecutable que se puede ejecutar dónde? 00:16:38
Se puede ejecutar en cualquier ordenador. 00:16:51
En un sistema que tenga el sistema operativo que he utilizado para la compilación 00:16:53
y el procesador que he utilizado para esta compilación. 00:17:05
Ahora, es posible que en los Windows, Windows 7, Windows 10, Windows 8, Windows 10, 00:17:09
Tengan 00:17:17
Una compatibilidad hacia atrás 00:17:21
Y que 00:17:24
No obstante yo la haya compilado 00:17:25
Para Windows 7 00:17:28
Windows 10 00:17:29
Tenga sus propias funciones 00:17:30
Pero mantenga algunas funciones 00:17:32
Legacy del pasado 00:17:35
Y que aun si yo lo he compilado 00:17:37
Para Windows 7 me funcione Windows 10 00:17:41
Puede ser 00:17:43
No es seguro 00:17:44
Como también los procesadores 00:17:46
No es que cada procesador que sale nuevo 00:17:49
Tiene un juego de funciones completamente nuevo 00:17:52
Y cambian cada uno 00:17:58
Al máximo añadirán funciones nuevas 00:17:59
Las viejas las tienen 00:18:02
Entonces si he utilizado funciones de un procesador de séptima generación 00:18:03
Ahora que estamos en la décimo cuarta 00:18:11
de 14 generación 00:18:14
pues a lo mejor sigue teniendo las mismas 00:18:16
operaciones, entonces a lo mejor funciona 00:18:19
lo que si no va a funcionar 00:18:20
es si yo pillo un ejecutable 00:18:23
para Windows e intento ejecutarlo 00:18:25
en Linux, pues no va a funcionar 00:18:27
porque no comparte 00:18:29
Linux con Windows 00:18:31
las mismas funciones 00:18:33
si vosotros bajáis 00:18:35
¿habéis bajado alguna vez un programa 00:18:37
que a un cierto momento dice 00:18:39
¿qué versión quieres bajar? 00:18:40
¿la de Windows, la de Linux o la de 00:18:42
Mac 00:18:44
Tienes que elegir la tuya 00:18:45
Probad a bajar una de Mac y a darle doble clic en vuestro Windows 00:18:47
¿Qué pasa? 00:18:50
Funciona 00:18:54
Porque los 0 y 1 que están allí dentro 00:18:54
Vuestro procesador y vuestro sistema 00:18:57
No son en grado de interpretarlo 00:18:58
No pongáis una máquina virtual 00:19:00
O instaláis intérpretes de esa cosa 00:19:04
Para que traduzca 00:19:07
El binario de Windows 00:19:08
En binario del sistema en el que estáis vosotros 00:19:10
Lo complicado es la cosa 00:19:13
Entonces, este es uno de los problemas de la compilación 00:19:14
Cuando yo compilo, he hecho mi juego y lo compilo para Windows 00:19:18
Eso no funciona en Linux 00:19:23
Y si os fijáis, hoy en día los juegos son para Windows 00:19:25
Hay pocos juegos para Windows 00:19:31
Y para poder jugar en Linux, si alguno de vosotros juega en Linux 00:19:35
Hay como emuladores 00:19:38
Pero directamente no se producen juegos para ser jugados en Linux 00:19:40
¿Por qué? 00:19:47
Porque el target de los videojuegos no son los que usan Linux 00:19:49
Normalmente Linux se usa en ámbito profesional 00:20:08
¿Cuántos de vosotros tenéis instalado Linux en casa? 00:20:10
Uno, dos 00:20:14
Ahora, si yo hago un videojuego y quiero que jueguen 00:20:15
Y digo, lo hago en Linux 00:20:19
Me lo compran ellos dos 00:20:20
y yo no hago BigDolla 00:20:22
se está mejorando esta cosa 00:20:24
en el sentido que ahora 00:20:47
habrá compilaciones 00:20:48
o programas 00:20:52
que directamente compilan en las dos versiones 00:20:54
y luego cuando tú te lo bajas 00:20:57
te bajará la versión correcta 00:20:58
sin que tú ni siquiera lo sabes 00:21:00
porque sabe la versión 00:21:01
de todas formas, normalmente los videojuegos 00:21:03
Están testeados y probados para Windows 00:21:06
Más que para Linux 00:21:08
A lo mejor te puedan funcionar 00:21:09
O porque tú has hecho algo 00:21:11
Como instalarte un emulador 00:21:13
Que intenta 00:21:15
Hay algunas distribuciones de Linux 00:21:16
En las que puedes jugar 00:21:20
Pero porque probablemente por debajo tiene un emulador 00:21:21
Entonces 00:21:24
Si el emulador funciona bien, bien 00:21:25
Si el emulador funciona de golem 00:21:27
Pues posiblemente te van peor que son en Windows 00:21:29
Porque no están normalmente probados 00:21:31
En ningún momento he dicho 00:21:33
No se puede hacer 00:21:36
Te haces tú un emulador 00:21:38
Te haces tú un intérprete 00:21:40
Pues lo puedes hacer 00:21:41
Pero claramente las grandes distribuidoras 00:21:42
Van al mercado más grande 00:21:45
Y sabemos que normalmente el usuario estándar 00:21:46
El que no es informático tiene Windows 00:21:49
Si tengo que desarrollar un juego o un programa 00:21:51
Para que la gente lo use 00:21:53
Pues prefiero ir 00:21:55
Una cosa un poquito distinta 00:21:57
Es por ejemplo Mac 00:22:01
Porque más que se hace su propio ecosistema 00:22:02
Dice el hardware es mío 00:22:05
Los programas que creo son míos 00:22:07
Te garantizo que funcionan fenomenal 00:22:09
Porque todo es compatible conmigo mismo 00:22:11
Porque lo pruebo solo conmigo 00:22:14
Y no tiene que ser como en el PC 00:22:15
Que yo puedo montarlo con piezas 00:22:18
De distintos fabricantes 00:22:19
Y tiene que interactuar con todo 00:22:21
Y tiene que funcionar con todo 00:22:23
Pues no, yo te garantizo que el hardware 00:22:24
Lo he hecho yo, por lo tanto funciona bien 00:22:27
Si, a cambio 00:22:29
Paga 00:22:30
Claro, pero Mac 00:22:32
Es un 00:22:45
Es un 00:22:46
No sé exactamente las 00:22:48
La parte de mercado 00:22:51
Que tiene, pero no es la mayoría 00:22:54
La mayoría de la gente 00:22:55
Es en Android 00:22:57
Entonces si tú quieres vender algo 00:22:59
Y lo quieres vender a un euro 00:23:01
Y te lo compra y tienes 00:23:03
Un millón de posible gente 00:23:05
Te lo compra o tienes 10 millones 00:23:07
De posibles compradores 00:23:09
Allí tienes que 00:23:10
Claro, también allí está marketing 00:23:12
Y está un montón de otras cosas 00:23:14
Sabes también que si alguien se ha comprado un iPhone 00:23:16
Posiblemente está más dispuesto a pagar algo 00:23:18
Porque el dinero no es importante 00:23:20
Y se enciende puros 00:23:22
Con billetes de 50 euros 00:23:24
¿No? 00:23:26
A lo mejor, hoy en día ya menos 00:23:28
Ahora también Android que cuesta más 00:23:30
Pero bueno 00:23:33
Es más complejo, ¿se entiende esto? 00:23:33
Entonces 00:23:37
El compilador se compila una vez 00:23:38
He hecho mi programa, he acabado 00:23:40
Esta es la versión definitiva, no tiene errores 00:23:42
Lo compilo 00:23:44
Pero lo tengo que compilar en base a un determinado sistema 00:23:45
Y tendré un ejecutable para ese sistema 00:23:49
Luego lo puedo compilar también en Linux 00:23:51
Y tendré el ejecutable para Linux 00:23:54
Y lo puedo compilar también en macOS 00:23:56
Y tendré el ejecutable para macOS 00:23:58
Lo puedo hacer 00:24:01
Pero cada vez que cambio algo aquí 00:24:02
Debería volver a compilarlo para los tres 00:24:05
¿Sí? Esta es la compilación 00:24:09
Ten en cuenta también que 00:24:13
Tengo un programa fuente 00:24:17
En el primer paso 00:24:19
Creo lo que se llama un programa objeto 00:24:21
¿Qué es el programa objeto? 00:24:23
Y luego 00:24:27
Al programa objeto 00:24:28
Le añado las librerías propias 00:24:31
De un sistema, de un sistema operativo 00:24:34
De un entorno, de un... 00:24:36
¿Dónde lo voy a ejecutar? 00:24:37
Y el linkado 00:24:39
El link, ¿vale? 00:24:41
De el código objeto 00:24:42
Que es lo que he producido yo 00:24:44
Con las librerías que he utilizado aquí 00:24:45
Como por ejemplo printf, scanf 00:24:48
Y cosas por el estilo 00:24:50
Pues esto de aquí me da el programa ejecutable 00:24:51
Que se ejecuta 00:24:54
En base a las librerías 00:24:56
Utilizadas en un sistema concreto 00:24:57
Entonces he usado 00:25:00
La librería de Windows 00:25:01
Si he usado la librería de Linux 00:25:03
Se usará en Linux 00:25:05
¿Cuál sería el concepto de librería? 00:25:06
La librería son 00:25:11
Estas funciones que no has 00:25:12
Desarrollado tú, pero que utilizas 00:25:14
Como por ejemplo, escribir en pantalla 00:25:16
¿Cómo se escribe en pantalla? 00:25:18
Con printf 00:25:20
Este printf dentro 00:25:20
Va a llamar 00:25:23
Las librerías 00:25:27
De sistemas que son 00:25:28
Un conjunto de funciones 00:25:30
Que proporciona el sistema operativo 00:25:32
Para que los lenguajes 00:25:34
De alto nivel los puedan utilizar 00:25:36
¿Con métodos y tal? 00:25:38
son conjuntos 00:25:41
una librería son 00:25:43
paquetes 00:25:45
de funcionalidades 00:25:47
paquetes para input y output 00:25:49
paquetes para gestión de red 00:25:52
paquetes para 00:25:54
y tú vas allí, te cargas 00:25:55
las librerías 00:25:57
que necesitas 00:25:59
si tu programa no va en internet 00:26:00
o en red, no te cargas la librería 00:26:02
de internet de red 00:26:05
y una vez que tienes las librerías 00:26:06
correcta, pues puedes utilizar 00:26:09
estos programas sin tener que 00:26:12
desarrollarlo tú, printf 00:26:14
te escribe en pantalla sin que 00:26:16
tú hayas tenido que comunicar con 00:26:18
la tarjeta video 00:26:19
y con el monitor diciendo como se 00:26:21
escribe esa cosa, pues quien te da 00:26:24
ese código, pues la librería 00:26:26
del sistema operativo que te dice, mira yo 00:26:28
tengo aquí esta función y si tú me la das 00:26:30
yo escribo en pantalla 00:26:32
¿sí? 00:26:32
¿dudas? 00:26:36
Y esta 00:26:37
Nosotros, presidente, ni la vemos 00:26:40
¿Sí? 00:26:42
Aquí, a menos que tú no vayas 00:26:44
A hurgar 00:26:47
En las entrañas 00:26:49
De los programas para mejorar 00:26:51
La velocidad, para que ocupen menos espacio 00:26:52
Y cosas por el estilo, entonces dice 00:26:55
Quito esta librería, quito estas funciones 00:26:56
O me reescribo una función aquí 00:26:58
Para hacerla más eficiente o más 00:27:00
Que haga lo que yo quiero 00:27:02
Pues esta parte aquí tú no la ves nunca 00:27:03
Tú ves sólo esta parte aquí 00:27:06
Y luego tienes un programita 00:27:09
Que te han dado ellos 00:27:12
Que te compila 00:27:14
Esto es 00:27:15
Por ejemplo, C++ 00:27:18
¿Sí? 00:27:19
Y si no, está el intérprete 00:27:22
¿Cómo funciona el intérprete? 00:27:24
Pues el intérprete es un programa 00:27:25
Se lanza este programa y está ahí ejecutándose 00:27:27
Ahora funciona este programa 00:27:29
Y a este programa le paso como parámetro 00:27:30
Mi código fuente 00:27:34
Le digo, oye, programa 00:27:35
Píllate este fichero donde yo he escrito una serie de instrucciones 00:27:38
Y vete línea por línea a ejecutarlo 00:27:43
Y él lo ejecuta y lo transforma en ceros y unos 00:27:45
Se lo da al procesador y el procesador hace cosas 00:27:49
Si ahora lo quiero lanzar otra vez en mi programa 00:27:51
El intérprete tiene que volver a ejecutarse 00:27:55
Mientras el compilador se hace una vez 00:27:58
Y luego tengo el ejecutable 00:28:03
Y lanzo solo esto 00:28:05
El compilador no lo vuelvo a utilizar 00:28:07
Hasta que no modifique esto 00:28:08
El compilador no me sirve más 00:28:11
Lo puedo hasta no instalar 00:28:13
Sin embargo 00:28:15
En el campo de la interpretación 00:28:17
Yo siempre necesito el intérprete 00:28:20
Si no está el intérprete 00:28:22
No puede hacer funcionar mi programa 00:28:24
Entonces, ¿cómo se hace? 00:28:26
Pues, quien quiere utilizar 00:28:29
Un lenguaje programado 00:28:30
Interpretado 00:28:31
Lo que hace es que 00:28:33
Se tiene que instalar un programita 00:28:35
Este requisito 00:28:37
Tengo que instalar el JRE 00:28:39
Para poder ejecutar programas en Java 00:28:41
O el intérprete de Python 00:28:43
Para poder ejecutar programas en Python 00:28:45
Cuando lo tengo instalado 00:28:47
En mi sistema 00:28:49
Cada vez que ejecutaré 00:28:52
Un programa en Java 00:28:54
El sistema en automático sabe que tiene que arrancar 00:28:54
La máquina virtual 00:28:57
La Java Virtual Machine 00:28:58
El JRE, el entorno de ejecución de Java 00:29:00
Y pasarle como parámetro 00:29:02
El programa que le estoy dando 00:29:04
Y lo hará de forma pseudocompleta 00:29:05
¿Sí? 00:29:08
Comparación 00:29:15
¿Vale? 00:29:15
Sobre la entrada 00:29:22
¿Vale? 00:29:23
Para poder hacer una compilación 00:29:25
Se necesita un programa completo 00:29:27
Porque la compilación es toda de golpe 00:29:29
Porque si yo tengo mi programa completo 00:29:32
Lo compil 00:29:34
Sin embargo el intérprete 00:29:35
Como va leyendo línea de per código 00:29:38
Línea de código, línea de código 00:29:40
En teoría puede hasta tener un trozo de programa 00:29:41
Y yo se lo doy al intérprete 00:29:46
Y él empieza a leer esto, esto, esto y esto 00:29:49
Y va de una línea en una línea 00:29:51
Esto facilita lo que se llama el debugging 00:29:53
La fase de, tengo un programa que funciona 00:29:56
Pero tiene errores 00:30:01
No errores semánticos, lo he escrito bien 00:30:03
Pero tiene errores, perdón, sintáticos 00:30:06
Sino tiene errores semánticos 00:30:08
Yo quiero que me calcule una cosa 00:30:10
Y de vez en cuando con ciertos datos 00:30:12
El resultado está mal 00:30:14
Entonces tengo que ver donde me he equivocado 00:30:15
¿Vale? 00:30:18
Si yo intento hacer un debugging 00:30:21
Y buscar los errores 00:30:23
Aquí, cada vez que hago un cambio 00:30:24
En el código fuente 00:30:27
Tengo que compilarlo desde cero 00:30:28
Y ejecutarlo para ver si es solucionado o no 00:30:30
Mientras esto 00:30:33
Tiene técnicas de debugging avanzadas 00:30:34
En el que puedo modificar el código 00:30:37
Mientras se está ejecutando 00:30:39
Lo que es 00:30:41
Interesante 00:30:43
La salida 00:30:45
Esto cuando hago un compilador 00:30:49
Genera un código objeto intermedio 00:30:52
Que luego se hará el linking 00:30:55
Con las librerías del sistema 00:30:56
Y desde aquí no produce nada 00:30:58
El intérprete se lee el código fuente 00:31:00
Y lo ejecuta 00:31:04
Pero no crea un nuevo fichero 00:31:05
Mecanismo de trabajo 00:31:07
La compilación se realiza antes de la ejecución 00:31:13
Antes se compila 00:31:15
Luego se ejecuta 00:31:17
Mientras aquí 00:31:19
En el intérprete 00:31:20
Sostancialmente se está compilando 00:31:23
Ejecutando a la vez 00:31:25
Pillo una sola línea 00:31:26
La compilo en código máquina 00:31:28
Y la ejecuto 00:31:31
Pillo otra línea 00:31:32
Código máquina y la ejecuto 00:31:33
Esto es más rápido 00:31:36
Porque una vez he hecho la compilación 00:31:41
Ya todo está traducido 00:31:46
Y no tengo que hacer trabajo 00:31:47
Este es más lento 00:31:49
Si yo tengo un programa que ejecuta 00:31:51
50 veces la misma instrucción 00:31:53
Por 50 veces se compilará 00:31:55
Y luego ejecutará 00:31:59
Y cuando tengo que volver a hacer 00:32:00
La misma instrucción 00:32:02
La compilaré otra vez 00:32:03
Y la ejecutaré 00:32:05
Por lo tanto, si me importa 00:32:06
La velocidad con que se ejecutan 00:32:09
Mis programas 00:32:11
Compilar es mejor que interpretar 00:32:12
Interpretación es más lenta 00:32:15
Memoria 00:32:16
El requisito de memoria 00:32:20
Es más debido a la creación de código objeto 00:32:22
¿Vale? Como se crea el fichero 00:32:24
Pues necesita más memoria que este de aquí 00:32:26
Porque este de aquí 00:32:29
No necesita crear el código fuente 00:32:30
Y un código objeto 00:32:33
¿Vale? Se utiliza directamente el código fuente 00:32:34
Para trabajar 00:32:36
muestra todos los errores 00:32:37
después de la compilación 00:32:41
todo al mismo tiempo 00:32:43
muestra 00:32:45
este de aquí, tú haces la compilación 00:32:45
y al final te viene un listado 00:32:49
de todos los errores 00:32:51
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
21
Fecha:
17 de septiembre de 2024 - 11:27
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 52″
Relación de aspecto:
16:10 El estándar usado por los portátiles de 15,4" y algunos otros, es ancho como el 16:9.
Resolución:
1152x720 píxeles
Tamaño:
76.78 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid