Intro Programación | Mediateca de EducaMadrid

Voy a grabar esta clase, por lo tanto, si habláis, me dais el permiso de grabar vuestras cosas, ¿vale? 00:00:00

Entonces, esta es la primera clase de programación. 00:00:09

Vamos a empezar con algunos conceptos teóricos que se quedarán allí. 00:00:13

A lo mejor a lo largo del curso, en determinados momentos, surgirán otra vez. 00:00:17

Entonces iremos a ver, oye, mira, ¿os acordáis de esta parte de aquí? 00:00:22

la desplegaremos un poquito y a lo mejor tendrá más sentido ahora mismo preguntarme lo que sea 00:00:25

si no lo entendéis, me paráis, pero hasta un cierto nivel porque estos son conceptos básicos 00:00:35

pero también completamente complejos entre comillas y entonces para ser para que empieza 00:00:47

hoy con la programación pues a lo mejor no se entienden ahora al cien por cien se necesita 00:00:55

construir un poquito más de infraestructura de programación para luego entender de verdad de 00:01:01

que ese estado si esto ahora mismo es no entiendo nada de lo que está diciendo pues daros algunos 00:01:06

días, preguntados claramente, pero daros algunos días para que esto con calma encaje, ¿vale? 00:01:13

Seguramente antes de que ellos lo pregunten en un examen o cosas por el estilo, ¿vale? 00:01:19

Programación y programas, ¿vale? Estos son más bien para que entendamos un poquito el 00:01:28

significado de algunas palabras, ¿vale? La programación, ¿qué es? Es la creación de 00:01:33

un conjunto concreto de instrucciones que un ordenador puede interpretar, denominado programa de ordenador. 00:01:39

La programación es lo que haremos nosotros para escribir un conjunto de instrucciones, un conjunto de comandos, 00:01:46

es aprender un idioma que el ordenador pueda entender. 00:01:56

Hoy en día esto está migrando, porque nosotros hoy en día con la inteligencia artificial es relativamente sencillo explicarle con lenguaje humano lo que queremos y él, la inteligencia artificial, que no sé qué es, pues lo traduce a una serie de conjuntos de código, a un conjunto de instrucciones que el ordenador puede interpretar. 00:02:03

Nosotros, por ahora, y en este curso en concreto, lo que intentamos hacer es evitar este paso. 00:02:28

O sea, ir a un nivel más bajo. 00:02:35

Cuanto más es bajo el nivel, más estoy cerca del procesador. 00:02:38

Yo puedo hablar con el procesador con varios distintos idiomas, distintos lenguajes. 00:02:44

Cuanto más cerca estoy a hablar en binario con el procesador, más estoy a bajo nivel. 00:02:51

Cuanto más lejos estoy del procesador, o sea que escribo cosas que el procesador no entendería nunca, pero que yo entiendo mejor porque son un nivel un poquito más abstracto, más estoy a alto nivel. 00:02:58

La programación con inteligencia artificial sería un nivel muy, muy alto. 00:03:13

Porque yo no necesito saber nada del procesador, del ordenador, 00:03:17

de qué tiene como hardware el ordenador mismo. 00:03:21

Simplemente le digo, cálculame, o sea, 00:03:25

créame un programa que calcula la serie Fibonacci. 00:03:27

Y él lo hace. 00:03:31

Es muy alto nivel, es muy abstracto. 00:03:32

No le estoy diciendo cómo, en qué lenguaje, cómo hacerlo. 00:03:35

Yo le digo solo lo que quiero. 00:03:38

¿Vale? Cuanto más me acerco a la estructura física, digamos, del ordenador, podría llegar a un cierto momento en programar, en hacer hacer al ordenador lo que yo quiero, simplemente dándole tiras muy largas de ceros y unos. 00:03:40

¿Vale? Eso sería muy bajo nivel. Antes se programaba así. 00:03:55

¿Habréis visto alguna película o documental donde había las tarjetas perforadas? 00:03:59

antes había un matemático 00:04:04

o un científico que se inventaba 00:04:07

un algoritmo pero no lo sabía 00:04:10

programar, se lo daba a otro 00:04:12

a otra figura 00:04:14

profesional que era el que traducía 00:04:16

lo que él quería hacer 00:04:18

en 00:04:19

hojas con agujeros 00:04:20

que representaban ceros y unos 00:04:24

y estas hojas con 00:04:26

ceros y unos eran interpretadas por los 00:04:27

ordenadores, eso era un nivel 00:04:29

muy bajo 00:04:31

Entonces, con el tiempo hemos crecido, hemos subido de nivel para que sea más fácil para nosotros programar, ¿vale? El ejemplo extremo de la inteligencia artificial es claramente más fácil programar la inteligencia artificial que programar en 0-1, ¿sí? 00:04:32

Entonces, ¿qué es el programa? El programa es ese conjunto de instrucciones que normalmente se escribe utilizando un lenguaje de programación. 00:04:49

El lenguaje de programación es un lenguaje, es un idioma con sus reglas tanto morfológicas como para hacer una frase que tú tienes que conocer para poder decir, mira, este comando es un comando concreto, un comando que puede funcionar, este comando no. 00:05:03

Esta palabra la puedo utilizar, esta palabra no. Esta palabra es una palabra reservada y quiere decir algo concreto para el ordenador, mientras esta otra la puedo utilizar como me da la gana y le puedo dar un nombre yo a mi programa, a mi variable, a mi lo que sea lo que quiero. 00:05:18

Entonces cuando yo estudio un lenguaje de programación 00:05:33

Lo que tengo que hacer es sostancialmente 00:05:37

Entender cuál es la sintaxis 00:05:38

Con la que se puede escribir un programa 00:05:42

Utilizando ese lenguaje de programación 00:05:46

Cada lenguaje de programación tiene su propia sintaxis 00:05:48

Su forma de, empieza con esta palabra 00:05:51

Luego después de esta palabra no puede ir esto 00:05:53

Pero sí puede ir este otro 00:05:56

Luego tiene al final de un comando 00:05:57

Tiene que ir un punto y coma 00:05:59

el siguiente comando 00:06:00

tiene que estar en la siguiente línea 00:06:02

lo que sea, las reglas de un determinado lenguaje 00:06:04

lenguajes distintos 00:06:07

pueden tener reglas completamente 00:06:08

distintas 00:06:11

esa es la parte fácil de la programación 00:06:12

aprender la sintaxis 00:06:15

de un lenguaje de programación 00:06:17

es 00:06:19

estudio puro y duro de memorización 00:06:19

de entender como es 00:06:23

y ya está, sencillo 00:06:25

lo difícil 00:06:27

es obtener el algoritmo, o sea, dado un problema, saber cuáles son los pasos concretos que tengo que hacer 00:06:28

para solucionar bien ese problema. 00:06:38

Una vez que yo sé el algoritmo, puedo elegir cualquier lenguaje de programación 00:06:42

y usando las reglas del lenguaje de programación voy a escribir, voy a decir al ordenador 00:06:47

el algoritmo en un idioma que él pueda entender. 00:06:54

¿Entiende más o menos? 00:07:00

Un lenguaje de pronunciación es un conjunto de símbolos y palabras 00:07:04

que el usuario tiene a su disposición para elaborar un programa. 00:07:08

¿Vale? 00:07:11

Entonces nosotros, para buena parte del primer trimestre, 00:07:11

quizás un poquito el segundo, 00:07:16

pues lo que haremos es introducir nuevas palabras mágicas 00:07:17

que me permiten comunicarle al ordenador lo que yo quiero hacer. 00:07:21

¿Vale? 00:07:24

Cada palabra añadirá un comando, una posibilidad de hacer algo distinto con respecto a lo que se podía hacer antes, ¿vale? 00:07:25

Y combinando estas varias posibilidades que yo tengo, combinando todos los comandos que me permiten hacer acciones distintas 00:07:35

o que permiten comunicar al ordenador que haga acciones distintas, 00:07:44

si las combino de tal forma 00:07:49

que cumplan con las reglas 00:07:51

con un algoritmo, con una secuencia 00:07:53

de pasos que se resuelve 00:07:55

un problema, pues habré hecho un programa 00:07:57

que sirve de algo. Si no, habré 00:07:59

hecho un programa. 00:08:01

Ejemplos de lenguaje 00:08:05

de programación son 00:08:06

lenguaje máquina, ensemblador 00:08:08

o de alto nivel. Esto es siempre 00:08:10

lo que decíamos antes de ir desde 00:08:12

más bajo nivel 00:08:14

a más alto nivel. Desde 00:08:16

más cerca del procesador 00:08:17

a más lejos del procesador. 00:08:20

El lenguaje máquina es un lenguaje especial 00:08:22

que cada procesador tiene, 00:08:26

o sea, procesadores de la misma empresa 00:08:30

probablemente tendrán lenguajes máquinas muy parecidos, 00:08:33

pero sustancialmente es una secuencia de ceros y unos 00:08:36

que el procesador puede interpretar para hacer un comando. 00:08:39

Por ejemplo, si yo tengo 0, 1, 1, 0, 1, 0, 00:08:44

Para el procesador quiere decir, oye mira, prepárate a hacer una suma 00:08:48

Ahora te voy a dar dos números, o te voy a dar dos zonas de memoria 00:08:52

O te voy a dar dos cosas, y tú con estas dos cosas las sumas y me das el resultado 00:08:56

Habrá otro código, me lo estoy inventando, que es 11101 00:09:02

Que en vez de decir, oye prepárate a hacer una resta 00:09:07

Ahora te voy a decir el primer número, el segundo número 00:09:10

Y luego tú lo que haces es una resta entre estos dos 00:09:15

Y así habrá una cantidad bastante grande de comandos que yo puedo decir al procesador para que el procesador funcione. Este es el lenguaje máquina. Es fuertemente legado al procesador y es muy eficiente porque es pensado para ese procesador. 00:09:17

Cada procesador tiene su lenguaje máquina y por lo tanto funciona muy bien. 00:09:35

A los procesadores, a los ordenadores, les encanta el binario. 00:09:40

Eso es todo binario y va súper rápido. 00:09:43

Puede hacer un mogollón de operaciones al segundo. 00:09:46

Cuando nosotros decimos esto, va a 2 gigahercios. 00:09:49

¿Qué son 2 gigahercios? 00:09:53

¿Qué es un hertz? 00:09:56

Un hertz es una unidad de medida que es 1 sobre s, 1 sobre segundos. 00:09:58

son cuántas operaciones 00:10:02

puede hacer en un segundo 00:10:05

2 gigaherzios quiere decir que 00:10:07

este procesador puede hacer de estas 00:10:09

operaciones básicas que hemos dicho antes 00:10:11

2000 millones 00:10:13

en un segundo 00:10:15

para las operaciones básicas 00:10:16

y de suma me resta más de una cosa 00:10:19

pues el procesador es 00:10:21

fenomenal, es mucho más rápido 00:10:22

que nuestro CPU, para otras 00:10:25

cosas el ordenador es 00:10:27

sí 00:10:28

entonces como programar en ceros y unos vale imaginaos que hay que hacer una suma vale la 00:10:29

suma es este código de ceros y unos vale ahora escriben ahora tengo escribir el número ahora 00:10:38

tengo hacer una resta cual era la de esta y tengo todo un listado de ceros y unos que 00:10:44

éste resta este suma sería un infierno es lo que se hacía antes pero antes también 00:10:48

el lenguaje de máquina probablemente tenía muchas menos operaciones posibles. Como esto es un infierno, 00:10:54

¿es programado en lenguaje de máquina? No. A un cierto momento de la historia, no sé en qué años 00:10:59

somos, pero bastante, 1900, no sé, me atrevo, 70, no lo sé, por ahí, dijeron ¿por qué no hacemos una 00:11:05

cosa que es crear un lenguaje que me esconde los ceros y unos y me transforma cuando yo tengo hacer 00:11:16

una operación en vez de poner ceros y unos pongo la palabra por ejemplo ADD ADD de sumar para mí 00:11:25

ser humano es una maravilla porque yo escribo ADD número uno y número dos y lo entiendo mucho más 00:11:34

que 0 0 1 0 0 1 1 1 0 1 0. ¿Qué pasa? Pero que a mí me gusta, al ordenador no. El ordenador quiere 0 y 1. 00:11:40

Entonces, lo que se inventaron es, hagamos un nuevo programa, que sea un nuevo lenguaje de 00:11:53

programación, que se llama Ensemblador, que es un poquito más alto nivel, que me viene contra mí, pero 00:12:00

cuando luego lo tengo que utilizar en el procesador necesitaré que alguien de 00:12:05

alguna forma, lo veremos dentro un rato, me modifique este ADD, que es lo 00:12:10

que quiero usar yo como ser humano, en el correspondiente 01001, que es el 00:12:17

que entiende el procesador. 00:12:23

Y esto fue un gran paso, fue una cosa muy interesante a esa época. Vieron que 00:12:27

Pero mientras que los problemas, los sistemas que creemos en informático son pequeñitos, esto era una abstracción suficiente, ¿vale? 00:12:32

Era mucho más cómodo que programar en ceros euros, pero seguía siendo una cosa bastante engorrosa, ¿vale? 00:12:44

Entonces, con el pasar del tiempo, empezar a decir, vale, ¿por qué no hacemos un paso más, vale? 00:12:52

Llegamos a un paso todavía más arriba. 00:12:57

Empezamos a hacer cosas que no tengan 00:13:00

gran relación con el procesador, 00:13:02

pero que sea bastante más fácil 00:13:08

para un ser humano entenderlo. 00:13:10

Hasta un límite en que si tú lees, 00:13:12

pues puedas entender porque parece una cosa humana. 00:13:15

Por ejemplo, el comando if, 00:13:20

que quiere decir sí. 00:13:22

Y tú dices, sí, esta cosa, 00:13:23

DEN hace esta cosa, ELSE hace esta cosa, ¿vale? 00:13:25

Que quiere decir, si esta condición es verdadera, entonces hace esta cosa de aquí, 00:13:30

un programa, una cosa, no lo sé, y si no, si esto era falso, hace una cosa distinta. 00:13:36

Y eso a nivel lógico de humano, tú lo lees, es un poco, no es lo que yo escribiría 00:13:42

en lenguaje natural, pero ya es bastante distinto, tanto de haceros y unos, 00:13:47

como en este de aquí que era un poco 00:13:52

retorcido y completo. 00:13:54

Y entonces, hemos ido hacia 00:13:56

los lenguajes de alto nivel. 00:13:58

Java es un lenguaje de alto nivel. 00:14:00

C es un lenguaje de alto nivel. C++, 00:14:02

Python, Ruby, 00:14:05

Kotlin, 00:14:07

hay mogollón 00:14:09

de lenguajes. 00:14:10

De vez en cuando viene fuera, 00:14:12

me sale 00:14:14

la necesidad de crear un nuevo lenguaje 00:14:14

para un determinado contexto 00:14:18

porque los lenguajes más 00:14:20

viejos a lo mejor no permiten 00:14:22

determinadas acciones que en ese 00:14:24

contexto se usan mucho, entonces 00:14:26

se dice, vale, hagamos una abstracción 00:14:28

si en Java, algo para decir 00:14:30

se necesita 50 líneas 00:14:32

de código cada vez que hago esta operación 00:14:34

que se hace mucho, porque, no sé 00:14:36

estoy pensando a 00:14:38

dispositivos wearable 00:14:40

esto que puedes 00:14:42

poner en los vestidos 00:14:44

y cosas de ese estilo, y 00:14:46

Java es muy engorroso porque no está 00:14:47

pensado para eso, entonces 00:14:50

de las funcionalidades que tú usas normalmente allí en Java no está pensado para eso, 00:14:51

pues me creo un nuevo lenguaje de programación que lo que hace es esconder estos 50 líneas de código Java 00:14:57

en un solo comando, que yo luego utilizaré muchas veces, ¿vale? 00:15:04

Entonces, cada lenguaje está pensado para resolver algunos problemas que a lo mejor otros lenguajes no resolvían bien. 00:15:08

Entonces, ay mira, he creado este otro. Algunos de esos lenguajes son un paso adelante. Dicen, ay mira, es perfecto, funciona mejor, son mucho más fáciles, son mucho más sencillos de utilizar. 00:15:19

Y otros, no. Entonces, algunos lenguajes de programación se crean y luego no se utilizan porque sí, has resuelto este problema, pero has complicado otros 20 problemas. No me interesa. 00:15:29

Por ejemplo, Python es uno de los lenguajes de programación que últimamente ha salido 00:15:39

muchísimo porque es bastante sencillo, se puede aprenderlo, es fácil, es rápido y 00:15:44

entonces a la gente le gusta. 00:15:53

Como primera aproximación a la programación es bastante bueno. 00:15:55

Es más fácil aprender Python que aprender Java, por ejemplo. 00:15:59

tiene cosas que java por ejemplo como java es fuertemente tipado o sea que trata mucho muy 00:16:05

bien los tipos de datos mientras python no y entonces para tú que quieres aprender saber 00:16:13

que es un tipo de dato te puede venir bien hasta si luego después decides de no utilizarlo 00:16:19

programando en python pero es bien que sepas que no. ok se entiende esto de bajo nivel alto nivel 00:16:24

que nos alejamos del profesor entonces los lenguajes de programación de alto 00:16:33

nivel imperativos vale un primer paradigma de programación que se creó es 00:16:40

el paradigma imperativo en un lenguaje imperativo se sienten un lenguaje 00:16:48

programación que es imperativo funciona con que yo describo al ordenador paso 00:16:53

por paso lo que tiene que hacer. 00:17:01

O sea, es imperativo 00:17:04

porque yo como emperador le digo 00:17:05

ahora haz esto, ahora haz esto, 00:17:07

ahora haz esto. 00:17:09

No le estoy diciendo a dónde quiero 00:17:11

llegar. No lo sé dónde tengo 00:17:13

llegar. Pero le estoy diciendo al procesador 00:17:15

oye, mira, pilla este 00:17:18

número, luego pilla este otro 00:17:19

número, multiplícalos 00:17:21

entre ellos y divide por dos. 00:17:23

¿Qué he obtenido? 00:17:26

Pillo dos números, lo multiplico y divido por dos. 00:17:29

¿A qué os suena? 00:17:32

¿Qué podría ser? 00:17:33

Cálculo de una media 00:17:40

o el cálculo del área de un triángulo. 00:17:41

¿No? Podría ser eso. 00:17:43

Ahora, yo no le he dicho lo que estoy 00:17:45

haciendo y cómo lo voy a hacer. 00:17:47

Yo no le he dicho lo que quiero tener. 00:17:48

Yo le estoy diciendo, tú tienes que hacer esto. 00:17:51

Pilla el número, paso uno. 00:17:53

Paso dos, pilla el otro número. Paso tres, 00:17:54

multiplícalos entre ellos. 00:17:57

O suma o no sé qué he dicho. Y luego divide por dos. 00:17:58

¿Sí? 00:18:01

El concepto es, vas 00:18:03

diciendo paso por paso 00:18:05

los comandos que tiene que hacer. Esa es la 00:18:07

programación imperativa. Cuando un lenguaje 00:18:08

de programación es imperativo, le está diciendo 00:18:10

esta forma 00:18:13

de programa. ¿Vale? Nosotros 00:18:15

en todo el, casi 00:18:17

todo el primer trimestre, trabajaremos 00:18:19

así, de forma imperativa, estructural. 00:18:21

¿Sí? 00:18:24

Lenguaje de alto nivel quiere decir 00:18:25

que una instrucción 00:18:27

sola de mi programa, 00:18:29

de mi lenguaje de programación, puede 00:18:31

englobar muchas instrucciones máquinas. O sea, que un solo comando de alto nivel puede hacer 00:18:33

varias operaciones en sembladores que serán traducidas en varias operaciones de lenguaje 00:18:43

máquina. Yo le digo como comando a más b dividido 2, punto y coma, esto es mi comando, pero en 00:18:51

realidad a nivel máquina se hará. Pilla el número A, vete a ver dónde está guardado, píllalo y 00:19:00

guárdalo aquí. Ahora vete a B, vete a ver dónde está guardado, píllalo el contenido y guárdalo 00:19:06

aquí. Ahora estas dos celdas de memoria que has pillado, multiplícala entre ellas y luego después 00:19:12

guarda el resultado en otro lado. Ahora este resultado aquí, divídelo por el número 2 y 00:19:20

guardado en otro lado. Todas estas operaciones para mí es una línea de código de alto nivel. 00:19:25

Cuanto más alto nivel, más es sencillo para mí hacer una cosa y se tendrá que traducir 00:19:31

en las equivalentes instrucciones de nivel matemático. 00:19:39

Entre los lenguajes de alto nivel que conocemos y que encontramos, 00:19:46

Podemos encontrar estos tipos de datos, ¿vale? 00:19:52

No estructurados. 00:19:54

Os suena BASIC. 00:19:57

BASIC era el lenguaje con el que yo casi empecé a programar en 1990 y pico. 00:19:59

¿Vale? 00:20:07

En particular, yo utilizaba QUICKBASIC. 00:20:08

Fue el primero que escribí. 00:20:12

¿Vale? 00:20:13

Eran programas, eran lenguajes no estructurados. 00:20:14

¿Qué quiere decir? 00:20:18

Que, sustancialmente, está basado en la línea de código. 00:20:19

o sea que cada línea típicamente era un comando, y luego estaba el infierno, el 00:20:21

go to. Go to, vete a. Quiere decir que mientras yo ejecutaba un programa en cualquier momento 00:20:30

puedo decirle cuando llegas aquí vete a la línea 37. Entonces él hacía la línea, llegaba aquí y 00:20:37

saltaba a la línea 37 y de allí seguía. Y luego a lo mejor a un cierto momento, y ahora vete a la 00:20:45

línea 140 y él saltaba la línea por el 140. No había una estructura. Era así. Era tú escribes, 00:20:49

escribes, escribes y en cierto momento te dice y si el usuario ha pulsado la tecla A vete a la línea 00:20:57

5000. Si ha pulsado la tecla B vete a la línea 4900. Pero mantener esa cosa era infernal. El 00:21:03

El GUTU es la razón de por qué a un cierto momento de la historia de la informática los lenguajes no estructurados no servían más, 00:21:13

porque cuando los sistemas se volvían demasiado complejos, tú tenías un código de un millón de líneas de código, 00:21:24

donde dentro había un montón de, ahora vete a las 5.000, ahora vete a las 149.000, ahora vete... 00:21:33

y mantener esa cosa 00:21:40

entender que estaba haciendo tu programa 00:21:42

era un infierno, porque tú tenías constantemente 00:21:44

que saltar de una parte a otra 00:21:47

del código a ver que estaba haciendo 00:21:48

donde seguía la 00:21:50

información, ¿vale? esta es no estructurada 00:21:52

mal, SEO 00:21:55

para nosotros 00:21:56

entonces, en un cierto momento la gente dijo 00:21:57

vamos a poner un poco una estructura 00:22:00

vamos a hacerlo mejor, y se crearon 00:22:02

los lenguajes de alto nivel, estructurados 00:22:04

como por ejemplo, C o Pascal 00:22:06

¿vale? 00:22:09

¿Qué pasa aquí? 00:22:09

Que sustancialmente 00:22:11

En vez de ser basado en líneas de código 00:22:12

Esto de aquí es basado en funciones o módulos 00:22:15

Es decir, que yo pillo 00:22:19

Una determinada funcionalidad 00:22:21

Un determinado conjunto de instrucciones 00:22:23

Que hace algo concreto 00:22:25

Y le doy un nombre 00:22:27

Por ejemplo, nuestro programa de antes 00:22:28

Que calculaba el área del triángulo 00:22:31

Yo lo guardo a un lado 00:22:33

Lo llamo 00:22:35

Calcular triángulo 00:22:36

y le escribo dentro las líneas 00:22:38

para poder calcular la área del triángulo 00:22:40

a partir de ahora 00:22:42

cuando yo quiero calcular la área de un 00:22:44

triángulo, en vez de escribir 00:22:46

el código que estaba escrito dentro 00:22:48

como aquí, o saltar a un 00:22:50

trozo de código de no sé dónde 00:22:52

que dice, y ahora empieza allí 00:22:54

pues llamo simplemente el nombre de la función 00:22:55

le digo, calcular este triángulo 00:22:58

todo se vuelve 00:23:00

más estructurado, todo se vuelve 00:23:04

más empaquetado, la información 00:23:06

porque lo que me calcula una determinada cosa le doy un nombre lo ponga aquí la calcula una 00:23:08

cosa distinta ahora esta área del cuadrado pues me crea otra función que se llama área 00:23:13

del cuadrado y pongo aquí como se hace ahora necesito serie de Fibonacci pues crea una 00:23:17

función que se llama serie de Fibonacci que me calcula la serie de Fibonacci con este de aquí 00:23:24

aquí se evita el uso del gotu, porque en vez de irte a una línea concreta, 00:23:31

tú no dices que vete a una línea concreta, tú dices, oye, mira, cuando llegas a este punto, 00:23:37

llama o ejecuta aquella funcionalidad que calcula la área del triángulo, 00:23:41

esté donde esté, aquí tienes que saltar allí y volver, ¿vale? 00:23:48

Y además, pudiendo darle un nombre, yo, programador, ya sé de qué va, ¿vale? 00:23:52

si eso se llama calcular el triángulo 00:23:57

asumo que una vez pasado 00:24:00

por ese código, pues si yo tenga 00:24:02

como resultado la red del triángulo 00:24:03

mucho más fácil 00:24:06

por respecto a, vete a la 375 00:24:08

y que hay en la 375 00:24:10

bajo la 375, miro y veo 00:24:12

que hay para calcular la red, ah, esta calcular 00:24:14

la red del triángulo 00:24:16

aun así 00:24:17

esto no es 00:24:20

la panacea, vale 00:24:22

basarse sobre funciones y módulos 00:24:23

Fue un buen paso adelante, pero cuando los sistemas empezaron a complicarse 00:24:26

ancora más, a llegar a situaciones también con internet, con programas 00:24:34

y proyectos que a lo mejor empezaban desde un proyecto anterior 00:24:41

y lo tenían que hacer más grande, cosa por el estilo, 00:24:46

los programas simplemente estructurados se complicaban. 00:24:49

cierto momento que decidieron elegir un nuevo paradigma de programación que es la programación 00:24:56

orientada a objetos. La nuestra. Lo que haremos nosotros. Nosotros empezaremos por aquí. ¿Vale? 00:25:02

Porque empezamos de lo básico, pero luego nos daremos cuenta que, ¡ay! os he engañado. En 00:25:09

realidad no estábamos haciendo esto, no estábamos haciendo esto. ¿Vale? Java es un lenguaje de 00:25:15

programación orientado a objetos. Y hoy en día, una buena parte de los lenguajes que se utilizan 00:25:21

y una buena o una mala parte de la programación se hace con programación orientadas a objetos. 00:25:30

¿Qué es esto? Aquí había líneas de código, al azar. Las hemos empaquetado en funciones. Y ahora 00:25:35

Ahora, lo que hacemos es agrupamos estas funciones en objetos. 00:25:46

¿Qué quiere decir? 00:25:52

Por ejemplo, nosotros hemos hecho una función que calcula el área del triángulo. 00:25:54

Y podría hacer una función que calcula el perímetro del triángulo. 00:25:57

Y una función que calcula la altura de un triángulo. 00:26:01

Todas estas tres funciones, que en este mundo serían cosas deslegadas entre ellas, 00:26:08

En realidad, lo que están haciendo es trabajar sobre el concepto de triángulo, ¿vale? 00:26:13

Sobre el objeto triángulo. 00:26:20

Entonces, lo que dice la programación orientada a objetos es que yo modelizo una cosa. 00:26:23

Por ejemplo, voy a modelizar la figura geométrica triángulo, ¿vale? 00:26:29

Y empaqueto dentro de esta cosa, hago un conjunto de funcionalidades, 00:26:33

Es un conjunto de características, un conjunto de elementos, todos relacionados con el triángulo, para que todos estén empaquetados ahí. 00:26:39

Entonces, en cualquier proyecto del mundo mundial en el que yo quiera utilizar triángulos, puedo pillar esta definición de objeto triángulo que he hecho y reutilizarla. 00:26:50

utilizarla. Entonces, si mi intención es hacer un programa, un videojuego donde hay gráfica 00:27:02

poligonal a triángulos y tengo que calcular muchos triángulos, me importo el objeto triángulo que 00:27:09

ha hecho alguien y allí dentro me encontraré la posibilidad de calcular el área, calcular el 00:27:16

perímetro, calcular la altura de todos los triángulos. Si ahora hago otro programa, otro 00:27:22

sistema, que en vez de ser un videojuego 00:27:28

es un programa 00:27:30

para gestionar 00:27:32

lotización de tierra 00:27:33

o cosas por el estilo, donde 00:27:35

se tienen que calcular allí también 00:27:38

triángulos, yo puedo reutilizar 00:27:40

este objeto triángulo 00:27:42

que había creado antes 00:27:44

para también este nuevo sistema. 00:27:45

Porque las funcionalidades 00:27:47

del triángulo siguen siendo esas. 00:27:49

Y así con el cuadrado, así con 00:27:52

el círculo, así con 00:27:54

otros conceptos. 00:27:55

¿Se entiende? 00:27:57

Aquí, solo líneas de códigos. 00:27:59

Un desastre. 00:28:02

Aquí se agrupan por funcionalidades 00:28:03

y aquí se agrupan por objetos 00:28:06

que tendrán un conjunto de funcionalidades 00:28:08

todas relacionadas con este objeto. 00:28:12

Si yo me creo el objeto coche, 00:28:15

en el objeto coche tendré las funcionalidades 00:28:17

de arrancar el coche, parar el coche, 00:28:20

chequear gasolina, 00:28:23

mueve coche vende coche que se yo todas las cosas que me pueden servir sobre un coche 00:28:25

lenguaje de programación entre objetos java c++ c sharp o python vale todas estas cosas por aquí 00:28:38

Y temas más que no dar nada. 00:28:48

Pero en este instituto, nosotros damos Java, C Sharp lo veréis si vais a segundo de DAM en programación de videojuegos, por ejemplo, utilizamos C Sharp. 00:28:51

No sé si en segundo de DAW se utiliza también en otros lados, puede ser. 00:29:00

Y Python, hay también clases de introducción a Python en SMR, por ejemplo. 00:29:05

¿Dudas? Vale. 00:29:13

Ahora, existen lenguajes de programación que no son imperativos 00:29:18

Que son declarativos 00:29:24

Es el opuesto a lo que decíamos antes 00:29:27

En el imperativo tú dices, haz esto, esto, esto, esto 00:29:30

Pero ¿a dónde quieres llegar? No me interesa 00:29:34

Tú haz esto, esto, esto, te digo que haces 00:29:36

El declarativo es un poco distinto 00:29:37

Tú hablas con el ordenador para sostancialmente decir 00:29:40

Yo quiero tener esta cosa 00:29:44

Luego, ¿cómo llegas allí? 00:29:46

Te doy un margen de flexibilidad 00:29:53

No lo sé 00:29:55

Pero yo este es el resultado que quiero 00:29:56

¿Vale? 00:29:59

No tan fácil, eso parece inteligencia artificial 00:30:01

No es eso, no es a ese nivel 00:30:03

¿Alguno de vosotros conoce SQL de base de datos? 00:30:06

Cuando tú usas una base de datos 00:30:12

Cuando tú haces una consulta a una base de datos 00:30:14

Con el lenguaje de SQL 00:30:16

tú no le estás diciendo 00:30:18

cómo tener esos datos 00:30:20

tú le estás diciendo, yo quiero 00:30:21

de todas mis bases de datos de vuelos 00:30:23

que hemos hecho el ejemplo antes 00:30:26

yo quiero todos los vuelos 00:30:27

que salen después 00:30:30

de la 9 y que empiecen 00:30:31

en Madrid y acaben en Roma 00:30:34

yo no te estoy diciendo cómo sacar 00:30:36

estos datos, te estoy diciendo que al final 00:30:38

lo que yo quiero es un listado 00:30:40

de todos los vuelos que tengan 00:30:42

estas características 00:30:44

Te estoy describiendo a dónde quiero llegar y esto te lo describo a través de un lenguaje, simple query language, que lo que me permite hacer es definirte lo que quiero tener y luego tú harás lo que quieres dentro para obtenerlo. 00:30:45

Esta es una forma completamente distinta del imperativo. Imperativo, haces esto, haces esto, haces esto. Llegarás donde tienes que llegar. Este de aquí, te estoy declarando donde quiero llegar y luego tú tendrás tus mecanismos para sacar los datos y obtenerlos. 00:31:04

También aquí hay programaciones, o sea, lenguajes funcionales y lógicos que son otro mundo, ¿vale? 00:31:19

Son, en vez de programación estructurada y la que veremos nosotros, 00:31:30

esos de aquí son interesantes porque pueden pasarse, pueden utilizar como, ¿cómo decirlo? 00:31:35

incógnita, como variable, como parámetro, en vez de pasar un valor, puedo pasar una 00:31:44

entera función. 00:31:53

Esas son cosas avanzadas. 00:31:55

Nosotros veremos algo de esto a mitad del tercer trimestre y lo veremos un segundo y 00:31:56

luego nos taparemos los ojos y veremos otro día será. 00:32:06

Por ahora son cosas bastante más avanzadas que en ciertos campos son fundamentales. 00:32:08

Hay campos en los que hacerlo con Java sería un infierno, sería un sistema lento, ineficaz y cosas por el estilo. 00:32:16

Y que si tú lo haces con programación funcional o lógica, pues posiblemente se te simplifica todo y va mucho mejor. 00:32:28

Por ejemplo, un campo donde se usa esto es el procesamiento del lenguaje natural. 00:32:34

Eso de entender lo que estás diciendo y transformarlo, por ejemplo, en un texto para poder hacer algo. 00:32:42

Pues allí los funcionales y lógicos funcionan mucho mejor que los estructurados en perfil. 00:32:50

¿Sí? Pero bueno, ¿esto para qué? Para que sepa que existe, ¿vale? Luego qué son, cómo se usan, no lo veremos. 00:32:57

Ahora, este señor de aquí es un programa que calcula la serie de fibonacci en el sembrador, ¿vale? En el sembrador. 00:33:07

¿Qué es la serie de fibonacci? La serie de fibonacci es la serie que empieza con 0 y 1, 00:33:20

cero y uno, me acuerdo nunca si es cero, uno o uno, y luego el siguiente número es la 00:33:24

soma de los anteriores, cero y uno, el siguiente es uno, uno y uno, dos, dos y uno, tres, tres 00:33:28

y dos, cinco, cinco y tres, ocho, y así, así, así, así, ¿vale? Es una serie muy 00:33:36

conocida porque, por ejemplo, las conchas del mar y cosas por el estilo siguen una espiral 00:33:43

y esa espiral sigue hacia la serie Fibonacci. 00:33:50

Las galaxias, cuando veis esa cosa con los ramos así, pues siguen la serie Fibonacci. 00:33:53

Una foto, que vosotros decís, esta foto me gusta mucho, si buscáis por ahí hay una 00:33:59

serie Fibonacci por algún lado. 00:34:03

Hay algo en nuestro cerebro que nos hace reconocer como interesante y guapo lo que sigue la serie 00:34:06

Fibonacci. 00:34:12

Entonces, toda esta cosa de aquí es como se programaría el ensemblador, no el lenguaje máquina, el ensemblador, eso de que yo, no sé si es verdad, pero lo han dicho desde 1970, ¿vale? 00:34:15

Y si os fijáis, yo estoy diciendo, mueve el registro cero, mueve el número dos, mueve el registro uno y ponle cero, mueve el registro dos dentro del registro uno. 00:34:30

Hace operaciones así básicas de pilla un trocito de memoria, cópialo en otro, pilla este trocito de memoria, sumale este, luego cópialo en otro. 00:34:42

Son todos comandos relativamente complejos. 00:34:51

Que si tú lo lees así, si no sabes en sembrador, no lo entiendes. 00:34:55

Estos son los mismos, mismo ejercicio, mismo programa, hace lo mismo. 00:35:04

es siempre calcular los elementos de la serie Fibonacci, pero en C y en Python. 00:35:12

Entonces, si os fijáis aquí, te dice, ahora, define find, find, ¿vale? Se está definiendo 00:35:19

una función de un cierto número. Si este número es cero, devuelve cero. Esto hasta sin saber, 00:35:27

en un cierto sentido, lo puede entender. Digo, mira, estoy definiendo Fibonacci y me está 00:35:36

diciendo que si tú quieres el cérimo, la posición cero de la serie Fibonacci, y este 00:35:42

de aquí es el cero, pues entonces lo que tiene que devolver es cero. Si lo que has pedido es el primer 00:35:50

elemento de la serie Fibonacci, o sea que el número es uno en vez de cero, pues entonces devuelve uno. Y si no, haz algo. 00:35:57

no se entiende 00:36:06

si yo no he hecho programación 00:36:09

esto no entiendo que está haciendo 00:36:11

pero ya es un pasito 00:36:13

más 00:36:15

cercano a como 00:36:16

podría hablar un ser humano 00:36:19

hay palabras que aquí dice si esto 00:36:21

entonces hace esto y si este otro 00:36:23

hace este otro, cosa que aquí no lo ves 00:36:25

hace lo mismo 00:36:27

aquí está haciendo lo mismo 00:36:29

está haciendo que si tú le pides el Fibonacci 00:36:31

de 0, te devuelve 0 00:36:33

Fibonacci de 1 es el deber de 1 00:36:35

y si no Fibonacci de n 00:36:37

es n-1 00:36:39

más n-2 00:36:41

lo veremos, tanto programa de 00:36:42

pero para que veáis también 00:36:46

que esto es 00:36:49

una parrafada de cosas raras 00:36:50

que no se entiende, ya 00:36:53

a un nivel más amplio, pues es algo 00:36:54

bastante más pequeño 00:36:57

más 00:36:58

porque cada una de estas opciones 00:36:59

aquí, en realidad 00:37:03

un conjunto de estas acciones. Una operación a alto nivel, una línea, un código de alto nivel, 00:37:04

pues posiblemente representa un conjunto de operaciones a nivel ensemblador. Y cada una 00:37:14

de estas a nivel ensemblador posiblemente será un conjunto de operaciones al lenguaje máquina, 00:37:21

eso de los 0 y 0 00:37:26

dudas 00:37:28

entonces esto es C 00:37:29

también 00:37:34

para el poquito más sencillo 00:37:36

esto es Python 00:37:38

fijaos en 00:37:40

prolog list 00:37:41

estos son declarativos 00:37:43

en declarativo 00:37:45

lo mismo que aquí se hacía en 00:37:48

no sé cuántas líneas de código 00:37:50

se hace en nada 00:37:52

entonces dependiendo de lo que 00:37:54

tú tienes que hacer pues a lo mejor por ejemplo en la programación lógica o funcional es mucho 00:38:00

más práctico mucho más sintética con respecto a tener que hacerlo imperativamente de hacer 00:38:08

esta fiesta de esta vez es dependiendo de lo que quieres desarrollar pues mejor utilizar 00:38:13

declarativo mejor decir nosotros siempre tendremos siempre si dudas hasta aquí tres 00:38:20

minutos de pausa. Entonces, nosotros hemos dicho que existe un nivel de programación muy bajo que 00:38:32

está a nivel de ceros y unos en el procesador, luego está un nivel intermedio, digamos así, 00:38:48

siempre bastante bajo, que se llama el ensemblador, o assembler, y luego por encima están los lenguajes 00:38:54

de alto nivel, que es donde nosotros trabajaremos. El problema es que para hacer esta cosa, para que 00:39:01

esta cosa funcione yo quiero escribir el lenguaje de alto nivel pero el procesador necesita ceros y 00:39:08

unos para poder ejecutar lo que yo le he dicho que ejecuta para que esto funcione se necesita 00:39:16

un mecanismo que me pide el lenguaje de alto nivel y los varios comandos del lenguaje nivel 00:39:22

de alto nivel, y que lo traduzca en ceros y unos que el procesador puede ejecutar. 00:39:29

Existen dos formas de hacer esto, la compilación y la interpretación. 00:39:36

El intérprete es un programa, un programa extra, otro programa, yo tengo mi programa que quiero 00:39:45

ejecutar, el programa este que calcula 00:39:53

la área del triángulo 00:39:55

vale, por un lado, necesito 00:39:57

otro programa 00:39:59

¿vale? que es el intérprete 00:40:01

que tendrá que ejecutarse, que 00:40:03

alguien ya ha hecho para que funcione 00:40:05

alguien a lo mejor ha programado el 0 00:40:07

si uno, no lo sé, pero este funciona 00:40:09

¿vale? que 00:40:10

recibirá como input 00:40:12

mis comandos, o sea 00:40:14

los comandos de mi programa 00:40:17

y por cada uno de estos comandos 00:40:18

hará la acción de 00:40:21

traducirlos en ceros y unos y dárselo al procesador. 00:40:23

Entonces hay en ejecución dos programas. 00:40:27

Uno es el mío y uno es el intérprete. 00:40:31

El intérprete está allí y yo le digo mira, el primer paso es 00:40:35

preñar el número, díselo al procesador y él lo traduce en ceros y unos 00:40:38

para que el procesador haga el paso que le dice. 00:40:43

El segundo es multiplica. Vale, ok, espera. 00:40:46

Lo traduzco en ceros y unos para que el procesador multiplique. 00:40:49

Ahora guarda el resultado en esta celda de memoria 00:40:52

Vale, espero que lo diga el procesador 00:40:56

El intérprete está recibiendo comando por comando y lo traduce 00:40:57

Recibe un comando, lo traduce, recibe un comando, lo traduce, recibe un comando, lo traduce 00:41:06

¿Se entiende con esto? 00:41:10

Sin embargo, la compilación o el compilador es otro programa también 00:41:13

que pero hace esta traducción 00:41:19

toda de golpe 00:41:21

es decir, yo te doy 00:41:22

mi programa, el compilador 00:41:25

lo pilla entero, él lo 00:41:27

traduce todo en una 00:41:29

secuencia de ceros y unos 00:41:31

en lo que viene a ser un ejecutable 00:41:32

un .exe 00:41:35

habréis visto alguna vez dándole 00:41:36

doble clic para arrancar 00:41:39

un juego o un programa 00:41:41

en vuestros ordenadores 00:41:43

una vez traducido 00:41:44

el compilador se apaga 00:41:46

ya no existe, ya no hace falta 00:41:48

yo tenía mi programa inicial 00:41:51

he arrancado el compilador para que hiciera la traducción 00:41:53

el compilador lo ha traducido entero 00:41:57

y ahora ya el compilador no me sirve 00:41:59

y lo que hago es que yo puedo ejecutar 00:42:01

ese programa en ese procesador 00:42:04

porque el compilador cuando compila 00:42:08

cuando hace esta traducción 00:42:11

hace la traducción en base al sistema en el que está 00:42:13

si yo tengo mi programa escrito en Java 00:42:17

o escrito en C 00:42:21

o que sigo, y lo compilo 00:42:22

para Windows 00:42:25

con un determinado procesador 00:42:27

me funcionará en todos los Windows 00:42:28

con ese determinado procesador, pero si intento 00:42:30

ejecutar esa cosa en un Linux 00:42:32

con un procesador distinto 00:42:35

no me funciona, porque tendré que 00:42:36

pillar un compilador para ese otro 00:42:38

sistema y volver a hacer 00:42:40

la compilación para ese sistema 00:42:42

que me dará un ejecutable 00:42:44

en el otro sistema. Cada sistema tendrá su propio 00:42:46

ejecutable. Es cuando vosotros bajáis un programa 00:42:50

de algún tipo y os dicen, oye, ¿qué sistema tienes? 00:42:53

Windows, Mac o Linux. Y tú eliges 00:42:57

tu sistema y te estás bajando el ejecutable para ese sistema. 00:43:02

¿Entiendes? El intérprete 00:43:08

vive mientras viva mi programa. 00:43:11

porque le voy pasando 00:43:14

comando a comando 00:43:16

y él lo interpreta en ese instante 00:43:19

el compilador 00:43:21

se compila una vez 00:43:23

y una vez compilado el compilador no me sirve 00:43:25

y funciona 00:43:27

el compilador 00:43:28

es dependiente 00:43:31

del sistema en el que estoy 00:43:33

el intérprete 00:43:36

el intérprete como tal 00:43:37

sí 00:43:39

yo necesito un intérprete que funcione 00:43:40

en Windows y un intérprete que funcione en Linux, algo parecido. 00:43:43

Pero una vez que tengo eso, el 00:43:48

programa que escribo yo, eso del triángulo, 00:43:51

me vale tanto para Linux como para Windows. 00:43:56

Yo tengo esto escrito en un determinado lenguaje y si se lo 00:44:00

paso como input al intérprete de Windows, me girará 00:44:03

en Windows. Si se lo paso como 00:44:07

input a un intérprete 00:44:10

que gira en Linux, pues me funcionará 00:44:13

también en Linux. 00:44:15

Entonces, tiene ventajas y desventajas 00:44:17

cada uno de estos. 00:44:19

Uno es más dependiente 00:44:21

de lo que hay por debajo 00:44:23

del sistema en que estoy, pero luego 00:44:24

gasta menos recursos porque una vez hecho 00:44:27

el compilador ya no lo tengo que ejecutar 00:44:29

otras veces. Mientras esté aquí 00:44:31

el intérprete siempre tiene que estar funcionando. 00:44:33

Es como una sobrecarga que tiene 00:44:35

siempre que existir. 00:44:37

¿Cuál es mejor? Ningún. 00:44:39

¿Cuál es peor? Ningún. 00:44:40

Depende de lo que tengo que hacer yo. 00:44:42

Dependiendo de qué es mi sistema, si es un sistema, por ejemplo, que tiene que ir rápido, 00:44:44

¿qué creéis que es más rápido? 00:44:50

¿Pasar comando por comando, que uno lo traduzca y que lo ejecute, o tener ya todo listo? 00:44:53

Por eso los videojuegos, por ejemplo, se compilan. 00:45:01

Y los juegos se suelen hacer en C++, algo para decir, que es un lenguaje que se compila 00:45:04

y una vez compilado funciona. 00:45:11

Pero los juegos tienen versiones distintas para Windows, para Linux, para un juego que 00:45:12

funcione en Windows no lo puedes jugar en el Mac. 00:45:20

Pero siempre que tú quieres un programa único que luego funcione, que sea muy portable, 00:45:27

funcione en muchos sistemas, pues que solamente con un intérprete que funcione. 00:45:33

Porque con esto deberías hacer muchas veces las compilaciones 00:45:38

y tener muchas versiones distintas del mismo programa. 00:45:42

¿Cómo funciona la compilación? Yo tengo un programa, ¿vale? 00:45:45

Un programa escrito en C, por ejemplo, aquí. 00:45:50

Ejecuto un compilador, ¿vale? 00:45:55

Y este compilador me traduce una buena parte 00:45:58

de este código en ceros y unos. 00:46:02

Además de eso, es posible que mi programa 00:46:06

utilice algunas funciones, algunos bloques de códigos 00:46:11

que no he escrito yo y que me dan automáticamente 00:46:16

el propio lenguaje de programación. 00:46:21

Printf es una función que escribe en pantalla. 00:46:27

Lo que está escrito aquí, me lo escribe en la pantalla. 00:46:31

Pero esta función de aquí, printf, no la tengo que programar yo. 00:46:36

C, este es el lenguaje en C, me la da ya hecha en una librería. 00:46:43

Yo puedo importar librería que han hecho otros y utilizar las funciones que me dan los otros 00:46:49

para evitar de tener que reescribir yo en cada programa una función que escribe en pantalla. 00:46:55

Si no hubiese esto, cada vez que yo empiezo un programa, debería escribirme el código para poder imprimir en pantalla y luego usarlo. 00:47:01

En vez de con esto, me lo dan ya hecho y yo lo uso. 00:47:08

Pero no está aquí. La definición de este printf yo aquí la uso, pero no sé cómo está hecho. 00:47:12

No sé qué programa es. Me la da una librería externa. 00:47:19

Entonces, aquí la guía sería, esto compila lo que he escrito yo y luego le pega detrás las librerías externas que me sirven. 00:47:25

y con esto hace un programa, un fichero, que dentro tiene el código máquina de mi programa 00:47:37

y el código máquina de todas las funciones que otro me han dado listas para ser ejecutadas. 00:47:48

En este fichero está todo lo que me sirve para poder ejecutar mi programa. 00:47:55

pero lo he tenido que hacer 00:48:00

para por ejemplo Windows 7 00:48:04

con un Core 2 Duo 00:48:06

la transparencia tiene un sonido 00:48:07

si yo quiero hacerlo 00:48:09

en Linux, no me vale 00:48:14

esto, porque esta traducción 00:48:15

aquí, estos ceros y unos, valen 00:48:18

para estos sistemas 00:48:20

no para sistemas Linux con otro procesador 00:48:21

entonces debería volver 00:48:24

a hacer este proceso para crear 00:48:26

un distinto ejecutable 00:48:28

que contenga empaquetado dentro 00:48:30

los ceros y unos, que puede 00:48:32

entender el otro procesador, el otro sistema 00:48:34

y todas las 00:48:36

funciones, pero interpretables 00:48:38

o sea, ejecutables por 00:48:40

el otro sistema, no para 00:48:42

el Windows, ¿entiendes? 00:48:44

una vez 00:48:47

empaquetado, yo, cuando se hace 00:48:48

así, pues, yo tengo el 00:48:50

programa, lo he escrito, lo compilo 00:48:52

para varias versiones, tendré 00:48:54

para Windows, para Linux, ¿eh? 00:48:56

y luego le digo a los usuarios, oye 00:48:57

cuando tú te bajas el programa, bájatelo para tu sistema. Bájatelo para Windows, bájatelo 00:48:59

para Linux, bájatelo para Mac, bájatelo para Android. ¿Se entiende? Vale. El programa 00:49:05

fuente es el programa que he escrito yo. El programa objeto es el programa de 0 y 1. 00:49:19

Sería esto, luego enlazado 00:49:26

El código objeto 00:49:29

Más las librerías externas 00:49:34

Me dan el programa ejecutable 00:49:36

O sea, código fuente 00:49:38

Esto 00:49:41

Esto es lo que está escrito 00:49:42

En el código fuente, alto nivel 00:49:44

Lo entiendo yo, pero la máquina no lo puede entender 00:49:46

Código objeto 00:49:48

Sería esta traducción en ceros y unos 00:49:50

Pero le faltan todas las librerías externas 00:49:53

A este punto 00:49:57

mezcla lo que es lo que ha generado con las librerías externas pre compiladas y 00:49:58

crea un único fichero que se les gusta más fuente programa objeto de programa 00:50:05

código objeto más las librerías externas me dan el programa si toda esta 00:50:10

compilación dudas sobre compilación la interpretación ya lo hemos dicho vale 00:50:17

analiza el programa fuente en lo ejecuta directamente línea por línea vale por 00:50:26

ejemplo estoy aquí es mucho más útil para buscar errores en compilación yo 00:50:31

hago mi proyecto en mi programa lo quiero quiero ver si hay errores por lo 00:50:36

tanto lo quiero lanzar lo que tengo hacer es una compilación y ahora he 00:50:41

compilado todo si esto no funciona porque un error tengo que solucionar el 00:50:45

error y volver a compilar y que cada vez que yo tengo una compilación un 00:50:50

ejecutable puede ejecutar esa versión para cambiarlo no puedo trabajar 00:50:55

sobre esta versión. Tengo que cambiar 00:51:01

el código fuente y crear una nueva 00:51:03

versión compilada. 00:51:05

Sin embargo, el 00:51:07

intérprete, como 00:51:08

funciona línea por línea, 00:51:10

hay sistemas 00:51:14

para decirle, oye, mira, aquí está el intérprete. 00:51:15

Te voy mandando los códigos y cuando veo 00:51:17

que no funciona, puedo cambiar 00:51:19

directamente el código aquí y 00:51:21

el intérprete empieza a interpretar la línea 00:51:23

cambiada, no la línea original. 00:51:25

Porque está interpretando 00:51:27

línea por línea. Entonces, para 00:51:28

encontrar errores, buscar errores, cosas por el estilo 00:51:31

con un intérprete es mucho más fácil 00:51:33

le puedo pedir muchas más cosas que un compilador 00:51:35

son cosas avanzadas 00:51:37

cuando veis debugging 00:51:42

en entornos 00:51:43

de desarrollo, a lo mejor 00:51:46

vendrá fuera cosas por eso 00:51:48

¿vale? 00:51:50

se puede modificar el código sobre la marcha 00:51:51

tengo el código fuente, le cambio 00:51:54

algo y veo lo que pasa, le cambio 00:51:56

otra cosa y veo lo que pasa, sin tener 00:51:58

que compilar todo cada vez 00:52:00

pero es mucho menos eficiente 00:52:01

¿vale? porque siempre tendrá 00:52:04

un programa extra 00:52:06

el intérprete que está trabajando 00:52:08

¿sí? 00:52:10

aquí tenéis un esquema que 00:52:14

sustancialmente os 00:52:16

compara compilador 00:52:17

e intérprete en base a varias 00:52:20

características, o sea, como es la entrada 00:52:22

como es la salida, cuál es la velocidad, cuánta memoria 00:52:24

usa, puede que es como gestionar 00:52:26

los errores, etc, etc 00:52:28

nos lo saltamos, lo usaremos 00:52:29

mañana para repasar esta parte. 00:52:32

Paradigma de programación, ya lo hemos 00:52:37

dicho, nos hemos visto, ¿vale? 00:52:39

Nosotros tenemos programación 00:52:40

estructurada, programación modular 00:52:42

y programación orientada a 00:52:44

objetos, ¿vale? Programación 00:52:46

estructurada es la que sustancialmente 00:52:48

se basa sobre secuencias alternativas 00:52:50

e iterativas, ¿vale? 00:52:53

Los que son una secuencia de instrucciones, 00:52:54

los if 00:52:57

y los while, que son 00:52:58

los que estudiaremos nosotros al principio, 00:53:00

luego empezaremos a empaquetar estas cosas en módulos en funciones entonces seguimos con 00:53:02

programación modular un poquito lo hemos dicho antes cuando veíamos la programación estructurada 00:53:11

que se basaba en funciones y módulos vale entonces de aquí esta es la base base se pasa a hacer 00:53:17

módulos y luego la programación orientada a objetos que en vez de lo que hemos dicho de 00:53:23

Yo me focalizo en un objeto general y empaqueto junto con este objeto todas las posibles funcionalidades y todas las características propias de ese objeto. 00:53:29

Modelizo un avión, pues le pongo como característica la velocidad máxima, cuánta gasolina puede tener y cuántos motores tiene. 00:53:40

Y luego como funcionalidades le puedo poner despegar, le puedo poner aterrizar, le puedo poner subir de altitud, que sí. 00:53:50

¿Vale? Todas estas cosas van juntas en el objeto y se mueven juntas. Si yo tengo que reutilizarla en entornos distintos, simplemente me reimporto todo el avión y tengo toda la información y todas las funcionalidades del avión ya listas. ¿Sí? Esa es la formación orientada a objetos. Es donde nos moveremos nosotros. 00:53:58

Nosotros empezaremos de aquí, nos moveremos aquí y llegaremos aquí. 00:54:21

Esto más o menos en diciembre. 00:54:27

Todo esto era genérico. 00:54:33

Lenguaje de programación genérico, etcétera, etcétera, etcétera. 00:54:34

Nosotros vamos a utilizar Java o Java o Java. 00:54:37

No lo sé, pronunciarlo como quiera. 00:54:41

En Italia, cuando yo estudiaba era Java, entonces para mí se ha quedado así. 00:54:42

En realidad probablemente es Java en inglés o Java en español. 00:54:48

Llamarlo como quiera. 00:54:52

es un lenguaje de programación orientado 00:54:52

a objetos, nosotros desde el primer 00:54:56

ejercicio que haremos y para siempre 00:54:58

estaremos utilizando otra programación 00:55:00

orientada al objeto, solo que nosotros 00:55:02

al principio ignoraremos esa cosa 00:55:04

veréis que hay 00:55:06

palabras raras, que diréis, ¿por qué tengo que 00:55:08

escribir esto? 00:55:10

tú escríbelo, ya en diciembre 00:55:11

entenderás por qué 00:55:14

su objetivo fundamental es 00:55:15

crear aplicaciones independientes 00:55:18

de la plataforma 00:55:20

¿Vale? Una de las cosas importantes e interesantes de Java es que es muy portable. Escribe una vez el código y ejecútalo en un mogollón de cosas distintas. ¿Vale? Esto me hace pensar que si es un compilador o un intérprete. 00:55:21

¿Usa un compilador o usa un intérprete Java? 00:55:37

En realidad usa los dos 00:55:45

Pero el hecho que yo quiero algo que escriba una vez 00:55:47

Y que luego se ejecute en todos los sistemas posibles 00:55:52

Es que probablemente me hace pensar que no lo puedo compilar 00:55:55

Porque lo que puedo hacer es tener intérpretes distintos en cada sistema 00:55:58

Y estos intérpretes no interpretan mi programa 00:56:03

Aún así, Java usa sea un compilador que un intérprete. 00:56:05

Ahora veremos en qué se trata. 00:56:10

¿Vale? 00:56:12

La idea es escribirlo una vez y ejecutarlo donde trabaje. 00:56:13

Entonces, ¿qué se hace en Java? 00:56:18

¿Vale? 00:56:21

Yo uso un editor. 00:56:23

Para programar en Java se puede utilizar cualquier editor de texto plano. 00:56:25

Yo puedo programar en Java con Notepad o con BlockNotes o con Notepad++ o con cualquier cosa que edite texto plano. 00:56:30

No con Word. Word no es un editor de texto plano. Word mete cositas raras dentro que yo no veo que pero están allí. 00:56:42

¿Habéis abierto alguna vez un fichero de Word con un Notepad? 00:56:50

hacerlo 00:56:54

y veréis que está toda cosa rara 00:56:56

ahí dentro que no es lo que he escrito ahí 00:56:59

¿vale? con lo que vemos casi yo puedo programar 00:57:00

en Java, no es aconsejable 00:57:03

hoy en día nosotros utilizamos IDE 00:57:04

¿vale? entornos de desarrollo 00:57:07

integrados ¿vale? 00:57:09

que son los que veréis también en 00:57:10

entornos de desarrollo ¿vale? 00:57:12

como NetBeans, como Eclipse 00:57:14

como IntelliJ 00:57:17

como 00:57:19

varios tipos de cosas, nosotros usaremos 00:57:20

Eclipse 00:57:23

Entonces, ¿qué hago? 00:57:26

Con este editor escribo el programa fuente. 00:57:27

El programa fuente estará en un fichero que es .java. 00:57:30

Entonces, eso es lo que veo yo. 00:57:33

Es lo que haréis vosotros. 00:57:35

Escribo el programa Java. 00:57:36

Cuando lo quiero ejecutar, cuando quiero ver si funciona o no, 00:57:38

el primer paso es una compilación. 00:57:42

Java pilla el fichero y lo compila, lo transforma, 00:57:46

en otro lenguaje que se llama el bytecode. 00:57:51

que no es el assembler, que no es el lenguaje máquina. 00:57:55

Es un lenguaje de alto nivel, pero un poco más bajo nivel con respecto al Java VDA. 00:58:00

Entonces, yo tengo mi programa en Java que lo he escrito yo. 00:58:09

Él, en automático, me lo transforma en bytecode. 00:58:12

Este pasaje sirve porque haciendo este paso de compilación, 00:58:16

el compilador puede optimizar el código. 00:58:21

Puede hacerlo mejor, puede hacerlo que se ejecute más rápidamente. 00:58:25

Y ahora tengo un nuevo fichero, que es el fichero .class. 00:58:30

Yo tenía programa.java, ahora se creará programa.class. 00:58:36

Yo tenía treno.java, ahora tendré treno.class. 00:58:40

Y aquí dentro, si yo voy a ver, no entiendo nada de lo que está escrito. 00:58:46

Pero no es lenguaje del procesador PRO. 00:58:51

Es un lenguaje propio de Java que tendrá que ser interpretado. 00:58:55

O sea, Java usa un intérprete también. 00:59:03

Este intérprete se llama la Java Virtual Machine. 00:59:06

Si tú quieres utilizar un programa de Java, necesitas en tu ordenador haber instalado la Java Virtual Machine. 00:59:09

Java Virtual Machine es un programita que se ejecuta cada vez que tú quieras ejecutar algo de Java. 00:59:18

Cuando tú quieres ejecutar este punto class, en automático el sistema lanza la Java Virtual Machine, que es un intérprete que te pilla comandos en bytecode, comandos escritos en bytecode, y los traduce al código máquina real. 00:59:25

Entonces Java hace los dos pasos. Compilación y luego interpreta el código compilado. Se compila en bytecode y luego se interpreta el bytecode. La compilación me permite optimizar el código para que sea más eficiente y luego se interpreta. 00:59:47

La ventaja de este sistema es que yo escribo el programa fuente una vez 01:00:06

y luego lo puedo ejecutar en cualquier sistema que tenga una Java Virtual Machine. 01:00:13

Serán los de Java, los que desarrollan Java, 01:00:21

que se encargarán de crear una versión de Java Virtual Machine para Windows, 01:00:24

una versión de Java Virtual Machine para Linux, 01:00:29

una versión de Java Virtual Machine para Mac, 01:00:32

una versión de Javaton Machine para Android. 01:00:35

El cliente mío, lo único que tiene que hacer es bajarse e instalarse la Javaton Machine para su sistema. 01:00:39

Y luego podrá ejecutar mi fichero en ByteDisk. 01:00:47

Yo lo escribo una vez, lo compilo una vez y luego distribuyo el punto clase. 01:00:53

Doy a quien lo quiera el punto clase. 01:01:00

Quien quiera ejecutar mi programa tendrá que instalarse la Java Vector Machine propia de su sistema y usar el mismo punto clásico. 01:01:01

Esto es potente porque permite a Java ser muy independiente del hardware por debajo. 01:01:10

Mi proyecto, mi programa, Java son independientes. Lo que es dependiente es la Java Vector Machine. 01:01:21

Pero ya se encargan ellos de crear la Java Vector Machine. 01:01:27

Luego lo veremos con más detalle, pero aquí, si vosotros vais en este equipo de software, aquí tenéis los programas que se han instalado en estos ordenadores, ¿vale? 01:01:30

Con la idea de, si en casa queréis la misma versión que está aquí, aquí tenéis el instalador que se ha utilizado para estos ordenadores, ¿vale? 01:01:50

Entonces, por ejemplo, está el Eclipse que vamos a utilizar nosotros, debería estar también la Java Virtual Machine, ¿de acuerdo? El .js, este .js de aquí, que es el 25 que vamos a utilizar nosotros, esto es el Java Development Kit, ¿vale? El Java, el kit de Java para desarrolladores, digamos así, ¿vale? 01:02:02

y aquí dentro incluye la java virtual no ship si vosotros tenéis windows en casa podéis traerlos 01:02:31

desde aquí a instalarlo si tenéis mac os tendréis que instalar la versión 25 de jvk para mac 01:02:40

luego hay un momento en que os explico que tenéis que hacer en casa para que esto funcione 01:02:47

Entonces, ¿se entiende esto? 01:02:55

Entonces, pregunta, ¿Java interpretado o compilado? 01:03:00

Los dos. Utilizan la compilación para pasar de Java a bytecode 01:03:04

y luego se interpreta utilizando como intérprete la Java Vector Machine. 01:03:10

La Java Vector Machine está dentro de un paquete que se llama JRE, 01:03:16

Java Runtime Environment, que está contenido dentro de JDK. 01:03:21

que es el que instalamos nosotros. 01:03:25

Solo que si soy un desarrollador, 01:03:27

instalo en JDK, si soy solo 01:03:29

un usuario, con el JRE es suficiente. 01:03:31

Sinceramente, 01:03:35

si soy un cliente, 01:03:36

lo único que me sirve es la Java Virtual Machine. 01:03:37

Si en vez de desarrollo en Java, 01:03:39

pues necesito algo más. Entonces 01:03:41

me instalo por ahí. La idea, 01:03:43

tengo un programa fuente, el programa fuente 01:03:47

f.java se compila, 01:03:49

¿vale? Aquí tendrá 01:03:52

f.clase y otras clases, 01:03:53

eso ya lo veremos en un futuro, pero en bytecode. 01:03:55

Ahora, si yo tengo una máquina aquí que tiene Windows, por ejemplo, 01:03:59

tendrá instalada la Java Vector Machine de Windows y mi bytecode será interpretable por él. 01:04:04

Si este es un Linux y tendrá instalada la Java Vector Machine para Linux, 01:04:10

pues usará este mismo bytecode para interpretarlo para trabajar en Linux. 01:04:14

Y si aquí tengo un Mac, tendrá la Java Vector Machine de Mac 01:04:19

y este mismo bytecode se podrá interpretar a través de esta cosa, ¿vale? 01:04:23

O sea, mi bytecode es único, lo que tiene cada máquina distinta será la Javalt Machine, 01:04:27

que no hago yo. Yo como programador no lo hago la Javalt Machine. 01:04:35

La Javalt Machine la encuentro ya en Internet y la puedo bajar. 01:04:39

Sí. 01:04:44

¿Dudas sobre esto de compilación, interpretación, Java, bytecode, cosas por el estilo? 01:04:49

Mañana lo repasamos, pero rápidamente. 01:04:55

Entonces, como última parte de hoy, el concepto de algoritmo. 01:04:57

Nosotros lo hemos dicho varias veces por aquí, un algoritmo, esto es un algoritmo, tenemos que crear algoritmo. 01:05:05

Es una de las partes más difíciles de la programación. 01:05:09

Vosotros tendréis que aprender a hacer algoritmos. 01:05:12

¿Qué es un algoritmo? 01:05:15

Un conjunto ordenado de filitos de operaciones que nos permiten hallar las soluciones a un problema. 01:05:16

Por ejemplo, ¿quién me puede hacer un ejemplo de algoritmo? 01:05:32

Objetivo 01:05:40

Quiero la media de las notas que he sacado este año 01:05:50

Vale, ¿cuál es el algoritmo? 01:05:54

El algoritmo sería 01:05:59

Pilla la primera nota 01:05:59

Súmale la segunda nota 01:06:01

Súmale la tercera nota 01:06:03

Y suma hasta la nota N 01:06:06

Una vez que has sumado todas estas N notas 01:06:08

Lo divide por N 01:06:10

Ese es el algoritmo 01:06:12

Los pasos que tengo que hacer para obtener lo que quiero 01:06:13

Un dulce, una receta es un algoritmo. Pilla la harina, échala en un bol, pilla los huevos, 01:06:16

échala en el bol, gira todo, añade el azúcar, ponlo en el horno. Esa es una secuencia de 01:06:27

pasos que llega a un objetivo, que soluciona el problema de tengo hambre y quiero un poco 01:06:34

de dulce. ¿Se entiende? 01:06:39

Pero una tarta 01:06:46

es un algoritmo. ¿Vale? 01:06:47

Cambiar una bombilla es un 01:06:50

algoritmo. Quita la 01:06:52

bombilla antigua, píllala 01:06:54

de repuesto. 01:06:56

Todo esto es 01:06:58

hacer un algoritmo es encontrar 01:06:59

la secuencia de pasos que me permite 01:07:02

resolver el problema que tengo, 01:07:04

que estoy intentando resolver. 01:07:05

¿Vale? 01:07:09

Pero algoritmos son la base de la programación. 01:07:09

Nosotros, nuestro trabajo 01:07:11

no es programar. Nuestro trabajo es 01:07:13

resolver problemas. 01:07:15

Nosotros nos darán problemas 01:07:17

y tenemos que encontrar cómo, por una 01:07:18

secuencia finita de posibles 01:07:21

comandos, podemos solucionar 01:07:23

ese problema. 01:07:25

Nuestro grande 01:07:27

trabajo es 01:07:28

encontrar algoritmos eficientes. 01:07:30

Porque el mismo problema se 01:07:33

podrá resolver de 500 01:07:35

modos distintos, pero solo 3 01:07:36

de ellos son buenos, porque lo 01:07:39

hace rápido y sin gastarme 01:07:41

un gocillón 01:07:43

de energía 01:07:45

y haciéndolo en tiempos humanos. 01:07:46

¿Entiende? 01:07:51

Los programas son 01:07:53

algoritmos escritos en un lenguaje 01:07:54

entendible por un ordenador. 01:07:56

La definición del algoritmo 01:07:58

tiene que seguir reglas sintáticas 01:08:00

y tiene que cubrir todos los casos posibles. 01:08:01

Me hago un ejemplo. 01:08:05

No sé si el más... 01:08:07

Pero yo quiero calcular 01:08:08

la área de un triángulo. 01:08:09

No digo... 01:08:12

¿Cómo se llama? Base, multiplico por la altura, divido 2. 01:08:13

Perfecto. Eso es el triángulo. 01:08:18

Pero a lo mejor yo debería comprobar que el tamaño de la base sea positivo. 01:08:23

Esa es parte del algoritmo. 01:08:31

Dame un número. Comprueba que sea positivo. 01:08:33

Dame otro número. Comprueba que sea positivo también. 01:08:37

A este punto hace la multiplicación. 01:08:41

Ya es un algoritmo un poquito más complejo de lo que he dicho antes. 01:08:43

El algoritmo tiene que ser determinista. 01:08:48

En cada momento el procesador tiene que saber cuáles son las instrucciones que tiene que ejecutar. 01:08:54

Esto es un poco complejo, pero la idea es que en cada momento el procesador no puede dudar sobre cuál es el siguiente paso. 01:08:59

Ese es otro mundo, es otro tipo de programación, no la nuestra. Existe. Pero nuestra programación es determinista. 01:09:10

Yo le estoy diciendo, imperativamente, haz esto, esto, esto, esto, y en cada momento el procesador tiene que saber, 01:09:20

ok, yo he hecho esto, ¿cuál es el siguiente paso? Esto, seguro. No puede haber o esto o esto aquí. 01:09:27

Lo puede haber, pero en base a una condición que o es verdadero o es falso. 01:09:33

Ya lo veremos cómo lo hacemos los condicionales. 01:09:42

Pero en cada instante el procesador puede evaluar lo que tiene, 01:09:44

es decir, con el 100% de seguridad, el siguiente paso que tenga que hacer, 01:09:49

el siguiente comando que tenga que hacer es este. 01:09:53

mira pilla un número pilla en un otro y luego si te apetece lo multiplicas pero 01:09:55

si no te apetece pues lo divides pues esto no es un algoritmo 01:10:06

Cartesiano algoritmo, me lo paso. Resolver problemas para que está formulado, o sea, 01:10:10

si yo quiero que calcule la área del triángulo, por favor, no me calculeis la circunferencia 01:10:21

de un circo. El algoritmo tiene que resolver lo que se ha pedido. Esto, grabáoslo aquí 01:10:29

como se llama tatuaje para los exámenes se os pide esto vosotros hacéis esto y funciona 01:10:36

perfectamente y es un cero 01:10:45

los algoritmos son independientes del ordenador cuando tú creas el algoritmo en el ordenador 01:10:46

no piensas en la secuencia de pasos te da igual en qué ordenador se ejecutará es independiente 01:10:55

Deben ser precisos, o sea, rigurosos en los pasos que tienen que hacer. 01:11:00

Los algoritmos tienen que ser finitos, algoritmos que no acaban nunca, no nos gustan. 01:11:05

Debe poder repetirse, al igual que una vez haya funcionado, de la vez el siguiente no. 01:11:13

Siempre tiene que funcionar bien. 01:11:18

Tiene que ser válido, tiene que ser eficiente, y si lo conseguís, ótimo. 01:11:22

O sea, que no haya otro algoritmo que sea más eficiente que él. 01:11:27

¿Ve? Esto no es un requisito para probar este examen. 01:11:33

Entonces, en cada algoritmo nosotros tenemos una serie de datos de entradas, 01:11:40

luego unos pasos de qué hago con estos señores y qué obtengo. 01:11:49

Dame base y altura, haz base por altura dividido dos, has obtenido la área del triángulo. 01:11:55

¿Sí? 01:12:04

dame harina, azúcar, huevos, y no sé qué más, haz lo que tienes que hacer hasta 01:12:06

Entonces, ahora, intentad pillar un Word, o lo que sea, y dados estos problemas, encontrad un algoritmo que resuelva estos problemas. 01:12:15

Es decir, quiero calcular la área de un cuadrado. 01:12:45

¿Qué datos pillo en entrada? 01:12:50

¿Qué operaciones hago? 01:12:52

¿Y qué salida me da? 01:12:54

Y ahora aquí ya estamos hablando de lenguaje de programación. 01:13:21

Esto es en papel, con palabras vuestras. 01:13:25

¿Qué comprobaciones tengo que hacer para poder hacer una secuencia de pasos que resuelva este problema? 01:13:28

Intro Programación - Contenido educativo

Del mismo autor…