1
00:00:00,000 --> 00:00:10,032

2
00:00:10,032 --> 00:00:10,990
DAVID MALAN: Bien.

3
00:00:10,990 --> 00:00:13,844
Esto es CS50
y esta es la lección 1.

4
00:00:13,844 --> 00:00:16,260
Recordarán, por supuesto,
que hace solo unos días

5
00:00:16,260 --> 00:00:19,270
introdujimos algunas bases
de programación e informática,

6
00:00:19,270 --> 00:00:21,220
y de pensamiento
computacional, por así decirlo.

7
00:00:21,220 --> 00:00:23,470
Y hoy haremos construcciones
con base en estas ideas,

8
00:00:23,470 --> 00:00:27,400
pero comenzaré la transición
hacia un aspecto más críptico,

9
00:00:27,400 --> 00:00:30,460
no obstante con un lenguaje mucho más
poderoso, básicamente una transición

10
00:00:30,460 --> 00:00:31,184
desde Scratch.

11
00:00:31,184 --> 00:00:33,475
Tuvimos la oportunidad
de configurar el problema

12
00:00:33,475 --> 00:00:36,490
desde cero, experimentar con
Scratch, arrastrar y soltar las piezas

13
00:00:36,490 --> 00:00:38,380
y recordar que el
verdadero objetivo de Scratch,

14
00:00:38,380 --> 00:00:40,210
más allá de tener un poco
de diversión para presumir,

15
00:00:40,210 --> 00:00:41,960
lo cual se puede lograr
con algo como esto,

16
00:00:41,960 --> 00:00:45,850
es explorar las ideas como
bucles, funciones y condiciones.

17
00:00:45,850 --> 00:00:47,560
Quizás algunas
expresiones booleanas o eventos.

18
00:00:47,560 --> 00:00:50,590
Realmente depende de cómo
se reúnan estos ingredientes.

19
00:00:50,590 --> 00:00:52,570
Hoy introduciremos un lenguaje

20
00:00:52,570 --> 00:00:54,610
que ha existido desde hace varias

21
00:00:54,610 --> 00:00:57,550
décadas, llamado C.
Es un lenguaje antiguo

22
00:00:57,550 --> 00:01:01,270
y francamente, después de CS50,
es probable que no les guste

23
00:01:01,270 --> 00:01:03,634
utilizar mucho este lenguaje,
si alguna vez se da el caso.

24
00:01:03,634 --> 00:01:06,550
Pero ha sido la base para muchos
de los lenguajes más modernos que

25
00:01:06,550 --> 00:01:07,140
llegaron después.

26
00:01:07,140 --> 00:01:10,000
Entonces, cerca de la mitad del semestre,
cuando hagamos la transición al lenguaje

27
00:01:10,000 --> 00:01:13,000
Python, y luego a SQL,
y después a

28
00:01:13,000 --> 00:01:16,240
JavaScript, verán muchas coincidencias
en cuanto a principios, sintaxis e ideas.

29
00:01:16,240 --> 00:01:19,198
Y verán que todo lo que hicimos
la semana pasada en Scratch

30
00:01:19,198 --> 00:01:21,640
está impregnado de todos
estos lenguajes distintos.

31
00:01:21,640 --> 00:01:24,940
Porque al final del día,
no aprenderán C en CS50.

32
00:01:24,940 --> 00:01:27,130
No aprenderán Scratch
o Python o JavaScript.

33
00:01:27,130 --> 00:01:29,963
Aprenderán bases en ciencias
de la computación y, en definitiva,

34
00:01:29,963 --> 00:01:31,850
en herramientas de programación.

35
00:01:31,850 --> 00:01:35,710
Entonces, comenzaremos
a traducir algunas de últimas ideas

36
00:01:35,710 --> 00:01:38,650
hacia una apariencia más críptica,
sin embargo, serán ideas básicamente

37
00:01:38,650 --> 00:01:39,950
idénticas, de la forma siguiente.

38
00:01:39,950 --> 00:01:42,940
Así que teníamos un programa
súper sencillo que simplemente

39
00:01:42,940 --> 00:01:47,230
mostraba en la pantalla de manera
predeterminada la frase, hello, world.

40
00:01:47,230 --> 00:01:51,880
Bien, comenzaremos
por traducir esto como algo textual,

41
00:01:51,880 --> 00:01:54,160
tal como se hace en la mayoría
de los lenguajes de programación,

42
00:01:54,160 --> 00:01:55,820
enfocándonos primero
solo en este bloque.

43
00:01:55,820 --> 00:01:57,840
A esta pieza morada
del rompecabezas,

44
00:01:57,840 --> 00:02:01,592
¿qué tipo de construcción
la llamamos en programación?

45
00:02:01,592 --> 00:02:02,550
Es como una función.

46
00:02:02,550 --> 00:02:05,260
Es un verbo o una acción,
que hace algo en Scratch.

47
00:02:05,260 --> 00:02:07,750
MIT decidió ponerlos
en color púrpura de manera arbitraria,

48
00:02:07,750 --> 00:02:10,125
pero son consistentes en el
programa porque todos son

49
00:02:10,125 --> 00:02:11,350
muy similares en espíritu.

50
00:02:11,350 --> 00:02:14,890
Ahora en C, a partir de hoy
y durante las semanas siguientes,

51
00:02:14,890 --> 00:02:18,160
esa misma pieza de color púrpura
empezará a verse como esto.

52
00:02:18,160 --> 00:02:21,520
Y la última vez, vislumbramos
 este printf, hello, world.

53
00:02:21,520 --> 00:02:23,650
Pero tengan en cuenta
que hay algunas características notables

54
00:02:23,650 --> 00:02:25,710
más allá de las palabras, hello, world.

55
00:02:25,710 --> 00:02:28,570
Existe un printf
y hoy veremos qué representa la f.

56
00:02:28,570 --> 00:02:31,180
Tenemos un paréntesis y acá
tenemos también un paréntesis cerrado.

57
00:02:31,180 --> 00:02:34,489
Y ese tipo de equilibrio será importante,
no solo intelectualmente, sino también

58
00:02:34,489 --> 00:02:36,280
sintácticamente,
porque la computadora

59
00:02:36,280 --> 00:02:38,220
espera que seamos súper precisos.

60
00:02:38,220 --> 00:02:41,920
Las comillas de apertura y de cierre,
veremos que encierran las palabras

61
00:02:41,920 --> 00:02:43,090
que se escriben en un programa.

62
00:02:43,090 --> 00:02:46,870
Entonces, aunque la última vez en Scratch
escribimos la palabra en un cuadro blanco,

63
00:02:46,870 --> 00:02:49,960
ahora haremos lo
mismo en su teclado

64
00:02:49,960 --> 00:02:51,377
pero encerrándolo entre comillas.

65
00:02:51,377 --> 00:02:54,460
Finalmente, tendremos esta molestia,
este punto y coma, el cual

66
00:02:54,460 --> 00:02:57,190
muchos lenguajes utilizan y que
simplemente quiere decir, fin de la idea.

67
00:02:57,190 --> 00:03:00,460
Para un programador equivale a
colocar un punto al final de una oración.

68
00:03:00,460 --> 00:03:02,560
Y se darán cuenta de que,
entre las frustraciones

69
00:03:02,560 --> 00:03:05,820
que experimentan los nuevos programadores,
incluido yo mismo hace un tiempo,

70
00:03:05,820 --> 00:03:08,831
es que realmente no nos damos cuenta
de estas cosas desde el principio.

71
00:03:08,831 --> 00:03:11,080
Y podrían escribir todo
desde su lógica y sentirse bien

72
00:03:11,080 --> 00:03:14,530
con su programa, tratar de ejecutarlo y
percatarse de que no funciona porque

73
00:03:14,530 --> 00:03:16,300
olvidaron algo
tan tonto como esto.

74
00:03:16,300 --> 00:03:18,610
Entonces, el punto clave
especial para este día es no

75
00:03:18,610 --> 00:03:20,200
sentirse frustrado
por cosas estúpidas.

76
00:03:20,200 --> 00:03:22,720
Definitivamente van a darse de topes
contra las paredes, aunque no del todo

77
00:03:22,720 --> 00:03:26,550
cuando vean lo que yo puedo ver
después de todos estos años de práctica.

78
00:03:26,550 --> 00:03:29,830
Pero en tan solo algunas semanas
comenzarán a notar ciertos patrones.

79
00:03:29,830 --> 00:03:32,230
Y los errores que seguramente
cometerán durante la primera semana

80
00:03:32,230 --> 00:03:35,720
serán mucho más obvios durante la segunda,
la tercera y las semanas subsiguientes.

81
00:03:35,720 --> 00:03:38,470
Entonces esto podría ser
una función en C. Vamos a

82
00:03:38,470 --> 00:03:42,010
combinarlo como un programa
completo, como ya vimos la última vez.

83
00:03:42,010 --> 00:03:44,080
Entonces, si tuvieran
que implementar este mismo programa,

84
00:03:44,080 --> 00:03:48,490
hello, world en C, estas serían todas
las líneas que tendrían que escribir.

85
00:03:48,490 --> 00:03:49,960
No pueden escribir simplemente printf.

86
00:03:49,960 --> 00:03:51,700
Deben configurar primero el programa.

87
00:03:51,700 --> 00:03:53,110
Ahora, ¿por qué ocurre ésto?

88
00:03:53,110 --> 00:03:57,160
Bueno, podemos analizar esto
solo con ver algunas de las palabras clave

89
00:03:57,160 --> 00:03:58,310
en este ejemplo de aquí.

90
00:03:58,310 --> 00:04:01,150
Lo resaltado en amarillo es main.

91
00:04:01,150 --> 00:04:03,160
Y algunos humanos
decidieron, muchos años atrás,

92
00:04:03,160 --> 00:04:05,710
ya saben, que cuando otro
humano escribe un programa,

93
00:04:05,710 --> 00:04:10,627
tiene que llamar a su función,
como lo veremos pronto, "main".

94
00:04:10,627 --> 00:04:12,460
La pudieron haber llamado
de cualquier otro modo,

95
00:04:12,460 --> 00:04:15,590
pero main era una buena palabra para
llamar a la parte principal del programa.

96
00:04:15,590 --> 00:04:20,110
Entonces este es nuestro equivalente
a la bandera verde en este lenguaje

97
00:04:20,110 --> 00:04:21,160
llamado C.

98
00:04:21,160 --> 00:04:23,800
Mientras tanto, si destacamos
otra palabra clave printf,

99
00:04:23,800 --> 00:04:27,680
será el equivalente, en C,
del bloque morado.

100
00:04:27,680 --> 00:04:30,580
Entonces printf únicamente
imprimirá algo en la pantalla.

101
00:04:30,580 --> 00:04:34,270
Mientras tanto, lo amarillo que está aquí,
es lo que llamaremos una cadena.

102
00:04:34,270 --> 00:04:38,930
Cadena es solo una palabra técnica para
una secuencia de caracteres o palabras,

103
00:04:38,930 --> 00:04:40,850
frases, párrafos, o lo que sea.

104
00:04:40,850 --> 00:04:43,390
Entonces lo que ahora está
resaltado en amarillo, es una cadena.

105
00:04:43,390 --> 00:04:46,880
Y noten que va junto con
printf, como podemos ver.

106
00:04:46,880 --> 00:04:49,810
Si se pone inmediatamente después
de la palabra printf, como hello, world,

107
00:04:49,810 --> 00:04:53,140
en el cuadro blanco que está
justo después de la palabra say.

108
00:04:53,140 --> 00:04:58,960
Y ahora las cosas se ponen más misteriosas
cuando lo resaltado en amarillo es stdio.h.

109
00:04:58,960 --> 00:05:01,330
Definitivamente, hasta ahora
es lo más críptico de las palabras clave.

110
00:05:01,330 --> 00:05:05,710
Esto es el soporte para
las entradas y salidas estándar.

111
00:05:05,710 --> 00:05:09,640
Y solo es una forma elegante de decir
que este archivo, como ya veremos,

112
00:05:09,640 --> 00:05:13,660
está relacionado, de algún modo,
con la impresión, lo cual es una salida,

113
00:05:13,660 --> 00:05:16,590
y de algún modo también se relaciona
con los teclados, que son la entrada.

114
00:05:16,590 --> 00:05:19,860
Entonces, en algún lugar de ese archivo,
veremos este tipo de funcionalidad

115
00:05:19,860 --> 00:05:21,810
que esperarían
que una computadora tuviera.

116
00:05:21,810 --> 00:05:23,732
Material de entrada y de salida.

117
00:05:23,732 --> 00:05:25,440
Y entonces veremos que eso
es el sitio de donde obtenemos

118
00:05:25,440 --> 00:05:26,940
este tipo de funcionalidad estándar.

119
00:05:26,940 --> 00:05:28,780
Scratch no tiene un equivalente.

120
00:05:28,780 --> 00:05:31,470
Solo es cualquier tipo de trabajo,
lo cual es bueno en Scratch.

121
00:05:31,470 --> 00:05:34,130
Mientras tanto, veremos
que lo que incluye esta palabra clave,

122
00:05:34,130 --> 00:05:35,700
literalmente, solo dice eso.

123
00:05:35,700 --> 00:05:40,740
Hey computadora, incluye la funcionalidad
estándar para entradas y salidas

124
00:05:40,740 --> 00:05:43,980
de manera que pueda hacer
algo interesante con mi programa.

125
00:05:43,980 --> 00:05:47,490
Y sin esa línea de código,
no podríamos hacer casi nada

126
00:05:47,490 --> 00:05:48,840
en este lenguaje C.

127
00:05:48,840 --> 00:05:51,720
Ahora demos un vistazo a algunas
otras piezas del rompecabezas,

128
00:05:51,720 --> 00:05:55,200
algunos conceptos que tal vez
son muy simples e intuitivos.

129
00:05:55,200 --> 00:05:57,420
Y luego a lo largo del día
haremos parcialmente la transición

130
00:05:57,420 --> 00:05:59,970
para escribir realmente un código,
daremos muchos ejemplos reales

131
00:05:59,970 --> 00:06:01,410
y también ejecutamos el código.

132
00:06:01,410 --> 00:06:03,118
Pero la última vez,
podrían haber implementado

133
00:06:03,118 --> 00:06:06,982
un bucle infinito, uno que simplemente
durara para siempre, con un bloque eterno.

134
00:06:06,982 --> 00:06:09,690
Y en Scratch, podrían tener
un bloque para decir algo, o que tuviera

135
00:06:09,690 --> 00:06:10,430
algo más en el interior.

136
00:06:10,430 --> 00:06:14,010
A partir de hoy, las mismas piezas
comenzarán a verse un poco raras.

137
00:06:14,010 --> 00:06:15,330
Se verán como esto.

138
00:06:15,330 --> 00:06:18,040
While (true), printf, hello, world.

139
00:06:18,040 --> 00:06:20,010
Y francamente, existe una
gran variedad de formas

140
00:06:20,010 --> 00:06:21,051
en las que se podría implementar.

141
00:06:21,051 --> 00:06:25,270
Solo estoy eligiendo la forma más simple,
relativamente, o la más convencional.

142
00:06:25,270 --> 00:06:27,090
Pero ¿por qué esto es lo mismo?

143
00:06:27,090 --> 00:06:30,490
Bueno, he resaltado en amarillo
la primera línea, while true.

144
00:06:30,490 --> 00:06:33,170
Y si bien, while es una especie
de palabra agradable en inglés,

145
00:06:33,170 --> 00:06:34,920
es solo una especie
de sugerencia intuitiva de que,

146
00:06:34,920 --> 00:06:38,370
cada vez que ocurra algo,
es como una especie de bucle.

147
00:06:38,370 --> 00:06:42,530
Y a la vez, lo que está entre
paréntesis es una expresión booleana

148
00:06:42,530 --> 00:06:44,280
que Scratch tiene
al arrastrar y soltar

149
00:06:44,280 --> 00:06:48,160
esas piezas en el bloque equivalente
cuando se dan las condiciones.

150
00:06:48,160 --> 00:06:51,020
Pero en este caso en particular,
solo estamos diciendo while (true).

151
00:06:51,020 --> 00:06:52,140
Entonces (true).

152
00:06:52,140 --> 00:06:53,910
(true) es como un sí.

153
00:06:53,910 --> 00:06:57,840
Y el otro día, dijimos que sí algo es
como el número 1, mientras que no es

154
00:06:57,840 --> 00:07:01,530
falso o como el número 0.

155
00:07:01,530 --> 00:07:04,650
Y eso es genial porque si tenemos
un mundo de verdadero, falso o un

156
00:07:04,650 --> 00:07:08,220
mundo de sí, no, o un mundo 1, 0, ese
maravilloso [INAUDIBLE] para el hardware,

157
00:07:08,220 --> 00:07:11,550
que tenemos en nuestras laptops
y en nuestros bolsillos, aquello

158
00:07:11,550 --> 00:07:14,480
que es la informática basada
en transistores y electricidad y todo

159
00:07:14,480 --> 00:07:16,430
aquello de lo que ahora
vamos a abstraernos.

160
00:07:16,430 --> 00:07:21,140
No importa cómo funciona ahora la
electricidad, ni los ceros, ni los unos.

161
00:07:21,140 --> 00:07:25,580
Solo sé que puedo representar
unos o ceros, unos o ceros,

162
00:07:25,580 --> 00:07:27,430
o su equivalente (true).

163
00:07:27,430 --> 00:07:34,850
Mientras la lámpara esté encendida,
o mientras sea (true), printf hello, world.

164
00:07:34,850 --> 00:07:36,950
Entonces la razón lógica
para que el código que

165
00:07:36,950 --> 00:07:39,654
tenemos en la pantalla imprima
hello, world, para siempre

166
00:07:39,654 --> 00:07:42,320
es porque así debe ser, como si nunca
hubiéramos apagado la lámpara.

167
00:07:42,320 --> 00:07:43,434
Así es mientras pemanezca encendida.

168
00:07:43,434 --> 00:07:46,100
Sigue haciendo lo mismo,
lo mismo y lo mismo, una y otra

169
00:07:46,100 --> 00:07:48,440
y otra vez, al igual que en Scratch.

170
00:07:48,440 --> 00:07:51,909
Mientras tanto, también
podríamos hacer lo siguiente

171
00:07:51,909 --> 00:07:53,450
después de varias iteraciones de eso.

172
00:07:53,450 --> 00:07:56,241
Podríamos tener un número finito de
iteraciones con este bloque de repetición.

173
00:07:56,241 --> 00:07:59,090
Este dice, por supuesto,
repite lo siguiente 50 veces.

174
00:07:59,090 --> 00:08:02,090
Ahora este, de seguro,
se verá un poco más feo.

175
00:08:02,090 --> 00:08:04,970
Esta es, probablemente,
la forma más convencional

176
00:08:04,970 --> 00:08:09,875
de traducir este bloque de Scratch a C.
Ahora parece ser mucho a la vez,

177
00:08:09,875 --> 00:08:12,000
pero una vez más, después de
un par de días o de semanas,

178
00:08:12,000 --> 00:08:13,374
comenzarán a ver los patrones.

179
00:08:13,374 --> 00:08:17,150
Déjenme resaltar algunas de
las funciones de este código.

180
00:08:17,150 --> 00:08:19,880
Entonces, resalté aquí,
en amarillo, solamente lo que

181
00:08:19,880 --> 00:08:21,590
llamaremos inicialización.

182
00:08:21,590 --> 00:08:26,300
Es como decir, hey computadora, dame
una variable y llámala i, solo porque sí,

183
00:08:26,300 --> 00:08:27,740
podría llamarla de cualquier forma,

184
00:08:27,740 --> 00:08:30,082
e inicialízala en 0.

185
00:08:30,082 --> 00:08:31,790
Así que otra vez,
como en álgebra, se podría

186
00:08:31,790 --> 00:08:34,896
tener x igual a 0, o y igual a 0
y esto sería igual a 0.

187
00:08:34,896 --> 00:08:36,770
Y a pesar de que
no hemos hablado de esto,

188
00:08:36,770 --> 00:08:42,710
podrían adivinar qué hace
la palabra clave, int, ¿tal vez significa?

189
00:08:42,710 --> 00:08:43,280
Entero.

190
00:08:43,280 --> 00:08:43,730
Correcto.

191
00:08:43,730 --> 00:08:45,590
Me refiero a que no tuvimos
la misma idea en Scratch.

192
00:08:45,590 --> 00:08:47,330
En Scratch, si se desea un número,
simplemente se escribe.

193
00:08:47,330 --> 00:08:48,871
Si se desea una palabra,
simplemente se escribe.

194
00:08:48,871 --> 00:08:51,020
Pero en C debemos ser
un poco más precisos.

195
00:08:51,020 --> 00:08:53,870
Debemos decirle a la
computadora el tipo de valor

196
00:08:53,870 --> 00:08:55,452
que se pondrán en las variables.

197
00:08:55,452 --> 00:08:57,410
No solo serán
números enteros.

198
00:08:57,410 --> 00:09:00,770
Podemos poner cadenas,
o verdaderos y falsos,

199
00:09:00,770 --> 00:09:03,240
o podemos poner
otras cosas por el camino.

200
00:09:03,240 --> 00:09:05,450
Así que esto simplemente
significa, hey computadora, dame

201
00:09:05,450 --> 00:09:09,050
una variable que contenga un entero,
un número como el negativo de 1, 0, 1

202
00:09:09,050 --> 00:09:12,470
y así sucesivamente,
pero inicia en 0.

203
00:09:12,470 --> 00:09:15,950
Haz que este número sea 0 de modo
predeterminado. Y eso es todo.

204
00:09:15,950 --> 00:09:18,260
Es un modo breve
y críptico de decirlo.

205
00:09:18,260 --> 00:09:20,360
Entonces el bloque
de este código dice lo siguiente.

206
00:09:20,360 --> 00:09:26,229
Hey computadora, solo para
estar seguro, ¿i es menor a 50?

207
00:09:26,229 --> 00:09:28,020
¿Se trata de una expresión
booleana verdadera o falsa?

208
00:09:28,020 --> 00:09:31,427
¿Entonces en este
momento i es menor a 50?

209
00:09:31,427 --> 00:09:32,510
Obviamente, porque es 0

210
00:09:32,510 --> 00:09:33,801
y por supuesto
que es menor que 50.

211
00:09:33,801 --> 00:09:36,570
Entonces la computadora
hará lo siguiente.

212
00:09:36,570 --> 00:09:38,570
printf hello, world.

213
00:09:38,570 --> 00:09:40,760
Entonces inicializará la variable.

214
00:09:40,760 --> 00:09:44,300
Comprobará que es menor a
cierto número, en este caso a 50.

215
00:09:44,300 --> 00:09:49,140
Y si esa condición es verdadera,
imprimirá hello, world.

216
00:09:49,140 --> 00:09:51,500
Y aún cuando ustedes
nunca antes hayan visto un código,

217
00:09:51,500 --> 00:09:54,890
quizás por un proceso de eliminación,
¿cuál es, probablemente, el paso siguiente?

218
00:09:54,890 --> 00:09:58,320
Probablemente, ¿qué
resaltaré después en la pantalla?

219
00:09:58,320 --> 00:09:59,900
Sí, la i más, más.

220
00:09:59,900 --> 00:10:05,060
Aún no es totalmente obvio lo que hace,
pero quizás adivinen que la i más, más

221
00:10:05,060 --> 00:10:08,810
es una forma convencional en
este lenguaje para decir, ya saben qué,

222
00:10:08,810 --> 00:10:12,210
sigue y cambia el valor de i por 1.

223
00:10:12,210 --> 00:10:16,440
Así que si 0 se vuelve 1, 1 se volverá 2,
2 se volverá 3, y así sucesivamente.

224
00:10:16,440 --> 00:10:19,890
Pero por ahora,
solo cambiamos el 0 por el 1.

225
00:10:19,890 --> 00:10:22,250
Así que en este momento, i es 1.

226
00:10:22,250 --> 00:10:23,510
¿Qué hace la computadora?

227
00:10:23,510 --> 00:10:26,300
Por ahora solo hace muchas
repeticiones de las cosas.

228
00:10:26,300 --> 00:10:29,810
Vamos a revisarlo nuevamente,
hey, ¿i es menor a 50?

229
00:10:29,810 --> 00:10:30,905
Una pregunta simple.

230
00:10:30,905 --> 00:10:33,890
i es 1, entonces
¿ahora i es menor a 50?

231
00:10:33,890 --> 00:10:34,880
Obviamente lo es.

232
00:10:34,880 --> 00:10:37,880
Y entonces imprimirá
de nuevo hello, world.

233
00:10:37,880 --> 00:10:39,190
Entonces se incrementará el valor de i.

234
00:10:39,190 --> 00:10:40,930
Así que ahora será 2.

235
00:10:40,930 --> 00:10:42,680
Se verificará de nuevo
esa condición.

236
00:10:42,680 --> 00:10:43,970
¿2 es menor que 50?

237
00:10:43,970 --> 00:10:45,380
Sí, obviamente.

238
00:10:45,380 --> 00:10:47,660
Y entonces imprimirá
de nuevo hello, world.

239
00:10:47,660 --> 00:10:51,190
Luego, se incrementará de nuevo
el valor de i y se convertirá en 3.

240
00:10:51,190 --> 00:10:52,940
Se verificará
de nuevo esa condición.

241
00:10:52,940 --> 00:10:54,080
¿3 es menor que 50?

242
00:10:54,080 --> 00:10:55,100
Obviamente.

243
00:10:55,100 --> 00:10:57,170
Y entonces imprimirá
de nuevo hello, world.

244
00:10:57,170 --> 00:11:01,700
Y continuará con el mismo proceso,
¿pueden adivinar cuántas veces?

245
00:11:01,700 --> 00:11:05,030
50 veces en total,
y no queremos aburrirnos con la

246
00:11:05,030 --> 00:11:06,140
historia completa.

247
00:11:06,140 --> 00:11:08,829
i será igual a 50, debido a
todo el montón de más, más.

248
00:11:08,829 --> 00:11:11,870
Y en este punto de la historia,
la computadora preguntará,

249
00:11:11,870 --> 00:11:14,060
¿es 50 menor que 50?

250
00:11:14,060 --> 00:11:15,020
No, obviamente no.

251
00:11:15,020 --> 00:11:17,510
Y en ese punto, el
código detendrá la ejecución.

252
00:11:17,510 --> 00:11:19,480
Y lo que sea que esté
por debajo en su programa,

253
00:11:19,480 --> 00:11:20,990
como inferior en su archivo,

254
00:11:20,990 --> 00:11:24,380
es lo que sucederá después, incluso
aunque no haya nada descrito allí.

255
00:11:24,380 --> 00:11:25,560
Entonces, de nuevo es críptico.

256
00:11:25,560 --> 00:11:26,900
Pero sigue este patrón.

257
00:11:26,900 --> 00:11:28,970
Y una vez que se sientan
cómodos con ese patrón,

258
00:11:28,970 --> 00:11:30,590
serán capaces de
escribirlo en un teclado

259
00:11:30,590 --> 00:11:33,756
y sabrán lo que se supone que
deben hacer, sin siquiera pensar en ello,

260
00:11:33,756 --> 00:11:34,820
así, metódicamente.

261
00:11:34,820 --> 00:11:37,160
El otro día, quizás ese fue el mayor
conjunto de piezas de rompecabezas

262
00:11:37,160 --> 00:11:39,290
con el que hayamos jugado,
aunque probablemente es

263
00:11:39,290 --> 00:11:42,770
solo una pequeña parte de algunos de
sus propios proyectos en Scratch.

264
00:11:42,770 --> 00:11:45,380
Pero de hecho esto esquematiza
bastante bien el código de C.

265
00:11:45,380 --> 00:11:47,240
No es tan colorido como aquel,

266
00:11:47,240 --> 00:11:51,860
pero verán que antes, cuando preguntamos
si x era menor que y, en código,

267
00:11:51,860 --> 00:11:53,520
en realidad lucía bastante idéntico.

268
00:11:53,520 --> 00:11:55,340
De hecho, podría ser un poco
más sencillo de observar.

269
00:11:55,340 --> 00:11:56,590
Tenemos solo algunos paréntesis.

270
00:11:56,590 --> 00:11:58,134
Tenemos el signo menor que.

271
00:11:58,134 --> 00:12:00,050
Y por supuesto, x y y,
las cuales, en este contexto,

272
00:12:00,050 --> 00:12:02,470
se supone que son variables,
de manera similar a x y y en álgebra.

273
00:12:02,470 --> 00:12:03,470
¿De dónde vienen?

274
00:12:03,470 --> 00:12:04,550
Ni idea.

275
00:12:04,550 --> 00:12:07,850
En este contexto, solo asumimos que
es parte de un programa más grande.

276
00:12:07,850 --> 00:12:12,740
Entonces, si x es menor que y,
imprime que x es menor que y.

277
00:12:12,740 --> 00:12:16,670
Y si x es mayor que y,
imprime que x es mayor que y.

278
00:12:16,670 --> 00:12:19,100
Si no, imprime que x es igual a y.

279
00:12:19,100 --> 00:12:21,290
Y justo así, como este
rompecabezas amarillo parece

280
00:12:21,290 --> 00:12:24,560
que abraza las piezas del
rompecabezas morado, de igual modo

281
00:12:24,560 --> 00:12:27,399
tenemos estos
corchetes, que tal vez nunca

282
00:12:27,399 --> 00:12:28,940
han tenido la ocasión
de utilizar en su teclado.

283
00:12:28,940 --> 00:12:33,360
Pero es probable que estén cerca de
su tecla Enter, en un teclado de los EE.UU.

284
00:12:33,360 --> 00:12:36,410
Parece como si
envolvieran las líneas de código

285
00:12:36,410 --> 00:12:38,540
que desean ejecutar.

286
00:12:38,540 --> 00:12:41,374
Ahora, hay algo curioso
que no he mencionado todavía

287
00:12:41,374 --> 00:12:43,790
y que veremos al regresar
a esta extraña diagonal inversa n.

288
00:12:43,790 --> 00:12:48,074
En un momento veremos
por qué se encuentra ahí.

289
00:12:48,074 --> 00:12:50,990
Ahora haré una pausa
porque ya teníamos listo algo.

290
00:12:50,990 --> 00:12:57,740
¿Tienen alguna duda sobre funciones,
bucles o condiciones, antes de que

291
00:12:57,740 --> 00:13:00,474
comencemos a
traducirlos de Scratch a C?

292
00:13:00,474 --> 00:13:01,140
¿Nada?

293
00:13:01,140 --> 00:13:02,067
¿Sí?

294
00:13:02,067 --> 00:13:04,400
PÚBLICO: ¿Por qué tenemos
dos signos más y no solo uno?

295
00:13:04,400 --> 00:13:04,870
DAVID: Buena pregunta.

296
00:13:04,870 --> 00:13:07,055
¿Por qué hay dos signos
positivos y no solo uno?

297
00:13:07,055 --> 00:13:09,930
Si se tiene solo un signo positivo,
y de hecho lo veremos muy pronto

298
00:13:09,930 --> 00:13:14,140
en un ejemplo, significa
añadir un número a la izquierda

299
00:13:14,140 --> 00:13:15,520
de un número a la derecha.

300
00:13:15,520 --> 00:13:18,961
Entonces, en este caso, es solo
porque parece ser la respuesta trivial.

301
00:13:18,961 --> 00:13:21,460
Es porque, si queremos tener
esta operación especial en donde

302
00:13:21,460 --> 00:13:23,293
no hay ningún número a la
derecha, únicamente tenemos que

303
00:13:23,293 --> 00:13:25,710
añadir un 1 al
número de la izquierda.

304
00:13:25,710 --> 00:13:29,110
Los humanos, muchos años atrás,
decidimos que más, más es demasiado breve

305
00:13:29,110 --> 00:13:31,570
y que aún no se
utiliza para otros fines.

306
00:13:31,570 --> 00:13:32,660
Así que eso es todo.

307
00:13:32,660 --> 00:13:34,580
¿Sí?

308
00:13:34,580 --> 00:13:36,686
Sí, justo ahí.

309
00:13:36,686 --> 00:13:43,955
PÚBLICO: [INAUDIBLE]

310
00:13:43,955 --> 00:13:44,830
DAVID: Correcto.

311
00:13:44,830 --> 00:13:47,496
No comenzaría a pensar en ello
como si tuviera un bucle en su interior,

312
00:13:47,496 --> 00:13:51,340
porque al final veremos
que pueden poner otro bucle

313
00:13:51,340 --> 00:13:54,190
que tenga la misma
palabra clave, dentro de otro,

314
00:13:54,190 --> 00:13:55,930
al ponerle sangría.

315
00:13:55,930 --> 00:13:58,120
Así que, piensen en ello
cuando necesiten un bucle

316
00:13:58,120 --> 00:14:01,960
como el que vimos
hace un momento,

317
00:14:01,960 --> 00:14:04,990
que el bucle se compone
de estas cuatro líneas.

318
00:14:04,990 --> 00:14:08,230
Y como algo que
solo ocurre de manera cíclica

319
00:14:08,230 --> 00:14:13,500
alrededor de todo el cuerpo
de éste código, por así decirlo.

320
00:14:13,500 --> 00:14:16,000
¿Alguna otra pregunta?

321
00:14:16,000 --> 00:14:18,004
¿Sí?

322
00:14:18,004 --> 00:14:20,115
PÚBLICO: ¿Por qué usamos
int para el método principal?

323
00:14:20,115 --> 00:14:22,240
DAVID: ¿Por qué usamos
int para el método principal?

324
00:14:22,240 --> 00:14:24,710
Dejen regreso a la quinta
diapositiva para explicarlo.

325
00:14:24,710 --> 00:14:26,920
Lo que ustedes preguntan,
solo para ser claros,

326
00:14:26,920 --> 00:14:33,430
es este ejemplo de aquí, donde nuestro
más simple y convencional, relativamente

327
00:14:33,430 --> 00:14:36,710
hablando, pero programa al fin,
hace la menor cantidad de trabajo posible,

328
00:14:36,710 --> 00:14:37,990
aquí también mencionamos int.

329
00:14:37,990 --> 00:14:40,030
También mencionamos
esta curiosidad, void.

330
00:14:40,030 --> 00:14:41,946
Permítanme posponer esta
respuesta por un momento

331
00:14:41,946 --> 00:14:45,021
hasta que tengamos el vocabulario
necesario para responder a eso.

332
00:14:45,021 --> 00:14:45,520
Bien.

333
00:14:45,520 --> 00:14:49,460
Entonces, hemos buscado funciones
int en bucles y en condiciones.

334
00:14:49,460 --> 00:14:53,040
También hay un par de piezas de otros
rompecabezas que analizamos antes.

335
00:14:53,040 --> 00:14:56,290
Pero por ahora, tomaremos
estas como nuestras únicas traducciones,

336
00:14:56,290 --> 00:14:59,620
solo para darles una idea
acerca de que, aunque la sintaxis es

337
00:14:59,620 --> 00:15:02,953
diferente, aunque que no hayan
escrito esos caracteres en su teclado,

338
00:15:02,953 --> 00:15:05,600
las ideas que vimos hoy
son las mismas que la vez pasada.

339
00:15:05,600 --> 00:15:10,030
Pero claro, incluso cuando los humanos
empezamos a escribir un código,

340
00:15:10,030 --> 00:15:12,520
este código es solo para caracteres
como el que está en la pantalla,

341
00:15:12,520 --> 00:15:16,936
el problema se mostró en otra lección, las
computadoras no hablan un pseudo código.

342
00:15:16,936 --> 00:15:18,310
Ellas no hablan inglés, per se.

343
00:15:18,310 --> 00:15:20,890
Y ni siquiera hablan en código, per se.

344
00:15:20,890 --> 00:15:24,800
¿Cuál es el único lenguaje
que entienden las computadoras?

345
00:15:24,800 --> 00:15:26,040
unos y ceros, es decir, binarios.

346
00:15:26,040 --> 00:15:29,140
A fin de cuentas, solo entienden
ceros y unos, y pueden hacer

347
00:15:29,140 --> 00:15:31,240
muchas cosas con ellos.

348
00:15:31,240 --> 00:15:37,000
Pero de algún modo, si yo, el humano,
escribo cosas como esta en mi pantalla,

349
00:15:37,000 --> 00:15:40,240
antes de que mi Mac o mi PC puedan
comprenderlas, lamentablemente,

350
00:15:40,240 --> 00:15:43,570
voy a tener que
convertirlas en ceros y unos.

351
00:15:43,570 --> 00:15:45,310
Y de vuelta a ese día,

352
00:15:45,310 --> 00:15:48,156
de vuelta incluso a este campus,
es posible que hace años hayan

353
00:15:48,156 --> 00:15:51,280
oído algo sobre las tarjetas perforadas,
un libro de historia, o algo similar, que

354
00:15:51,280 --> 00:15:54,340
captura efectivamente
simbologías como esta.

355
00:15:54,340 --> 00:15:58,641
La gente regresó a los programas
en binario, al menos en un principio,

356
00:15:58,641 --> 00:16:01,390
después inventaron otros
lenguajes más bonitos

357
00:16:01,390 --> 00:16:04,540
y luego inventaron otros
lenguajes aún más bonitos.

358
00:16:04,540 --> 00:16:07,420
Pero al final de todo, nuestras
computadoras Intel Inside

359
00:16:07,420 --> 00:16:09,310
solamente entienden esto.

360
00:16:09,310 --> 00:16:13,000
Pero por suerte, los humanos
no necesitamos preocuparnos

361
00:16:13,000 --> 00:16:16,090
de por qué esos
ceros y unos significan,

362
00:16:16,090 --> 00:16:20,320
hey computadora, imprime hello, world
en la pantalla, debido a lo siguiente.

363
00:16:20,320 --> 00:16:22,629
De aquí en adelante
escribiremos el código fuente.

364
00:16:22,629 --> 00:16:24,670
Y eso es técnicamente
lo que hicimos con Scratch.

365
00:16:24,670 --> 00:16:26,753
A pesar de que arrastraron
y soltaron las piezas de rompecabezas,

366
00:16:26,753 --> 00:16:28,060
estaban escribiendo el código fuente.

367
00:16:28,060 --> 00:16:32,920
Una sintaxis parecida a la humana,
pero más digerible para nosotros.

368
00:16:32,920 --> 00:16:36,430
Pero al final necesitamos convertir
el código fuente en código máquina,

369
00:16:36,430 --> 00:16:41,830
ceros y unos que los CPU de Intel,
u otros CPU, entiendan.

370
00:16:41,830 --> 00:16:45,790
Por suerte otros humanos antes
que nosotros inventaron un software,

371
00:16:45,790 --> 00:16:50,470
llamados compiladores, cuyo único
propósito es traducir el código fuente

372
00:16:50,470 --> 00:16:54,451
como lo hemos visto en la pantalla,
mediante códigos máquina, ceros y unos.

373
00:16:54,451 --> 00:16:56,200
Y de hecho, se trata de
toda una área de investigación

374
00:16:56,200 --> 00:16:59,300
en ciencias de la computación sobre
cómo hacerlo bien y rápidamente,

375
00:16:59,300 --> 00:17:01,000
especialmente para
programas muy grandes.

376
00:17:01,000 --> 00:17:07,480
Es una herramienta que utilizaremos
en CS50 para no preocuparnos

377
00:17:07,480 --> 00:17:09,820
de cómo suceden
esas traducciones.

378
00:17:09,820 --> 00:17:13,129
Y para lograrlo, generalmente
utilizaremos el mismo entorno,

379
00:17:13,129 --> 00:17:15,159
algo llamado CS50 IDE.

380
00:17:15,159 --> 00:17:18,310
IDE significa entorno
de desarrollo integrado,

381
00:17:18,310 --> 00:17:21,250
que es una forma elegante de
llamar a un entorno de computación

382
00:17:21,250 --> 00:17:22,493
idéntico para todos nosotros.

383
00:17:22,493 --> 00:17:24,909
Porque, sobre todo cuando
nos iniciamos en programación,

384
00:17:24,909 --> 00:17:27,950
una de las frustraciones más comunes
es seguir un montón de instrucciones

385
00:17:27,950 --> 00:17:31,670
en nuestra Mac o PC, solo
para lograr que el entorno sea

386
00:17:31,670 --> 00:17:34,420
idéntico al del que está al lado,
pero invariablemente, algunos

387
00:17:34,420 --> 00:17:36,211
tenemos versiones
de navegador diferentes

388
00:17:36,211 --> 00:17:38,170
o tenemos diferentes
versiones de Mac OS o Windows.

389
00:17:38,170 --> 00:17:41,294
Y es un dolor de cabeza tratar de
estar todos en la misma sintonía.

390
00:17:41,294 --> 00:17:44,410
Y así es cada vez más común
en la industria, incluso en las empresas,

391
00:17:44,410 --> 00:17:47,170
que todos tengamos un
entorno de desarrollo uniforme,

392
00:17:47,170 --> 00:17:49,480
incluso si todos no tienen
las mismas computadoras.

393
00:17:49,480 --> 00:17:52,060
Entonces, todo aquello a lo que
tendrán acceso a partir de hoy,

394
00:17:52,060 --> 00:17:55,520
incluso después del curso,
será un entorno que lucirá así.

395
00:17:55,520 --> 00:17:58,390
Este entorno de desarrollo
integrado está basado en la web.

396
00:17:58,390 --> 00:18:00,970
Y para aquellos que
estudiaron algo de CS antes,

397
00:18:00,970 --> 00:18:04,900
es similar a Eclipse, NetBeans,
Visual Studio, o herramientas como esas.

398
00:18:04,900 --> 00:18:08,260
Pero si no están familiarizados, pueden
pensar en ello como una aplicación web.

399
00:18:08,260 --> 00:18:11,800
Un sitio web en el que tendrán
nombres de usuario y contraseñas que

400
00:18:11,800 --> 00:18:14,530
les permitirán iniciar sesión y
ver, esencialmente, un entorno

401
00:18:14,530 --> 00:18:17,294
como este, que tiene una gran ventana
en donde se puede escribir el código,

402
00:18:17,294 --> 00:18:19,210
tal como lo hemos visto
en la pantalla hasta el momento.

403
00:18:19,210 --> 00:18:21,730
Tendrá una ventana conocida
como terminal en la parte inferior

404
00:18:21,730 --> 00:18:25,060
donde, tal como haremos hoy, pueden
escribir comandos de nivel inferior

405
00:18:25,060 --> 00:18:27,859
y decirle a la computadora qué hacer,
incluso sin la ayuda de un ratón.

406
00:18:27,859 --> 00:18:29,650
Y entonces, al igual
que muchas Mac OS y Windows,

407
00:18:29,650 --> 00:18:32,010
podrán ver todos
sus archivos y carpetas.

408
00:18:32,010 --> 00:18:34,372
Esto es en la nube,
por así decirlo.

409
00:18:34,372 --> 00:18:36,580
Y tendrán cierta cantidad
de gigabytes en la nube

410
00:18:36,580 --> 00:18:39,285
y solo ustedes tendrán acceso,
o sus compañeros de clase

411
00:18:39,285 --> 00:18:42,160
si ustedes les dan acceso,
y podrán entrar a este entorno.

412
00:18:42,160 --> 00:18:44,826
Y tendrán acceso, por supuesto,
desde cualquier sitio que tenga internet.

413
00:18:44,826 --> 00:18:47,890
Incluso si no tienen buen
internet durante las vacaciones

414
00:18:47,890 --> 00:18:50,500
o mientras van hacia la
escuela o practican deportes,

415
00:18:50,500 --> 00:18:54,250
también pueden descargar una versión
sin conexión del mismo entorno.

416
00:18:54,250 --> 00:18:56,560
Y también hay un modo nocturno,
si son de ese tipo de personas.

417
00:18:56,560 --> 00:19:00,010
Pero veamos cómo
utilizamos este entorno.

418
00:19:00,010 --> 00:19:02,920
O más bien, a fin de
cuentas, cómo programamos.

419
00:19:02,920 --> 00:19:06,120
Entonces, me conecté
previamente para ver el CS50 IDE.

420
00:19:06,120 --> 00:19:07,780
Me puse aquí en modo nocturno.

421
00:19:07,780 --> 00:19:11,110
La dirección es CS50.io y pueden
seguirla desde aquí si lo desean.

422
00:19:11,110 --> 00:19:14,560
Pero tal vez es mejor que vayan
a un ritmo más lento por su cuenta,

423
00:19:14,560 --> 00:19:17,140
ya sea alrato, para ver la serie
de problemas, o posteriormente.

424
00:19:17,140 --> 00:19:20,130
Ahora escribiré
mi primer programa.

425
00:19:20,130 --> 00:19:22,560
No me importa lo que
esté pasando a la izquierda

426
00:19:22,560 --> 00:19:27,090
pues aún no tengo archivos ni carpetas,
excepto esta carpeta que se ve aquí.

427
00:19:27,090 --> 00:19:30,570
De modo predeterminado, todos
tendrán su propia carpeta de trabajo

428
00:19:30,570 --> 00:19:33,420
y es en donde pondrán sus
series de problemas y archivos.

429
00:19:33,420 --> 00:19:36,420
Ahora la ocultaré dando
un clic en el icono de la carpeta,

430
00:19:36,420 --> 00:19:38,624
para simplificar
lo que vemos.

431
00:19:38,624 --> 00:19:40,290
Y ahora verán
dos secciones en la pantalla.

432
00:19:40,290 --> 00:19:43,630
El editor de código, aquí arriba, es donde
pueden escribir el código, no aquel.

433
00:19:43,630 --> 00:19:46,740
Y luego, aquí abajo, está
la ventana llamada terminal.

434
00:19:46,740 --> 00:19:49,080
Entonces escribiré
mi primer programa.

435
00:19:49,080 --> 00:19:53,670
Primero daré clic en Archivo, Guardar,
al igual que en una Mac o una PC.

436
00:19:53,670 --> 00:19:56,100
Y llamaré a esto, hello.c.

437
00:19:56,100 --> 00:20:01,080
Por convención, cualquier
programa que escriba en C

438
00:20:01,080 --> 00:20:02,460
tendrá la terminación .c.

439
00:20:02,460 --> 00:20:06,300
Al igual que en
Scratch termina en .sb2,

440
00:20:06,300 --> 00:20:08,100
si lo notaron en su Mac o PC.

441
00:20:08,100 --> 00:20:13,350
Por convención, en C siempre es c
y siempre se usan minúsculas.

442
00:20:13,350 --> 00:20:15,240
Y por convención,
no se usan espacios,

443
00:20:15,240 --> 00:20:18,390
se usan guiones bajos o guiones,
como cuando se crean archivos,

444
00:20:18,390 --> 00:20:22,240
de otro modo se dificulta hallar
las cosas en el espacio de trabajo.

445
00:20:22,240 --> 00:20:25,176
Entonces, tengo un archivo
o una etiqueta llamada hello.c.

446
00:20:25,176 --> 00:20:27,550
Puedo hacer esto rápidamente
porque ya lo he hecho antes,

447
00:20:27,550 --> 00:20:32,670
pero escribiré
el programa siguiente.

448
00:20:32,670 --> 00:20:36,994
printf("hello, world;)"
y guardamos.

449
00:20:36,994 --> 00:20:38,910
Noten que, de algún
modo, mi código está

450
00:20:38,910 --> 00:20:41,820
muy colorido, aunque lo escribí
fuera del teclado de mi Mac.

451
00:20:41,820 --> 00:20:43,486
Verán lo mismo en su PC.

452
00:20:43,486 --> 00:20:47,130
Esto pasa porque muchos IDE que se
integran en los entornos de desarrollo,

453
00:20:47,130 --> 00:20:49,860
colorean el código del
código fuente, con el fin de

454
00:20:49,860 --> 00:20:53,440
llamar la atención hacia las
funciones u otras palabras clave.

455
00:20:53,440 --> 00:20:55,930
No tiene ningún significado
y no se almacena en el archivo.

456
00:20:55,930 --> 00:20:58,500
Es solo una función en la
interfaz gráfica del usuario

457
00:20:58,500 --> 00:21:00,570
que se obtiene automáticamente.

458
00:21:00,570 --> 00:21:02,520
Pero ¿cómo ejecuto este programa?

459
00:21:02,520 --> 00:21:06,177
Como en su Mac o PC,
¿como ejecutan un programa?

460
00:21:06,177 --> 00:21:07,260
PÚBLICO: Le damos clic.

461
00:21:07,260 --> 00:21:07,890
DAVID: Sí, le damos clic.

462
00:21:07,890 --> 00:21:09,306
Tal vez damos
doble clic en un icono.

463
00:21:09,306 --> 00:21:11,820
En iOS o Android
solo se toca un icono.

464
00:21:11,820 --> 00:21:15,750
Pero en entornos de
programación esto es posible.

465
00:21:15,750 --> 00:21:19,290
Y en Mac y PC se puede escribir
un software tan simple como este,

466
00:21:19,290 --> 00:21:21,540
guardarlo y luego dar
doble clic en un icono.

467
00:21:21,540 --> 00:21:25,440
Pero en realidad, los aspirantes
a especialistas en sistemas,

468
00:21:25,440 --> 00:21:29,090
o quien quiera hacer cosas más
poderosas con las computadoras,

469
00:21:29,090 --> 00:21:31,484
pueden hacer mucho
más con el teclado,

470
00:21:31,484 --> 00:21:33,150
incluso si no escriben
tan rápidamente.

471
00:21:33,150 --> 00:21:35,983
Porque nada que escribamos
 en el teclado será tan largo

472
00:21:35,983 --> 00:21:36,720
o detallado.

473
00:21:36,720 --> 00:21:39,300
Pero se darán cuenta de que
es mucho más fácil y flexible

474
00:21:39,300 --> 00:21:42,930
porque pueden hacer más de aquello
que hacen los entornos gráficos actuales.

475
00:21:42,930 --> 00:21:46,200
Así que todo consiste en decir
que desean ejecutar ese programa,

476
00:21:46,200 --> 00:21:48,540
de hecho necesito compilarlo.

477
00:21:48,540 --> 00:21:55,020
Recuerden que compilar significa
tomar algo que se ve así en código

478
00:21:55,020 --> 00:21:56,760
y convertirlo en esto.

479
00:21:56,760 --> 00:22:01,080
Entonces necesito ejecutar
mi código fuente en un compilador

480
00:22:01,080 --> 00:22:02,580
para obtener el código máquina.

481
00:22:02,580 --> 00:22:04,690
Y hay varias maneras de hacerlo.

482
00:22:04,690 --> 00:22:07,180
La primera forma que
intentaré es la siguiente.

483
00:22:07,180 --> 00:22:10,050
Haré clic en la parte azul de
mi pantalla, que en lo sucesivo

484
00:22:10,050 --> 00:22:11,758
llamaré ventana
del terminal.

485
00:22:11,758 --> 00:22:14,160
Es un término de la vieja escuela que
simplemente describe a un cursor

486
00:22:14,160 --> 00:22:16,800
donde pueden escribir
comandos y palabras.

487
00:22:16,800 --> 00:22:17,820
Ampliamos aquí.

488
00:22:17,820 --> 00:22:19,350
Y haré lo siguiente.

489
00:22:19,350 --> 00:22:23,914
clang, en lenguaje C, es un
compilador del lenguaje C,

490
00:22:23,914 --> 00:22:25,830
y luego escribiré hello.c.

491
00:22:25,830 --> 00:22:29,579
Es posible que no estén
acostumbrados a esto en Mac y PC,

492
00:22:29,579 --> 00:22:32,370
pero si crecieron con Dos, Linux,
o algún otro sistema operativo,

493
00:22:32,370 --> 00:22:33,390
es posible que lo estén.

494
00:22:33,390 --> 00:22:35,910
Ahora oprimiré la tecla Enter

495
00:22:35,910 --> 00:22:37,600
y parece que nada sucede.

496
00:22:37,600 --> 00:22:40,340
En este entorno de
programación y en CS50 IDE

497
00:22:40,340 --> 00:22:43,860
se ejecuta un sistema operativo
llamado Ubuntu Linux, el cual

498
00:22:43,860 --> 00:22:48,660
es diferente, pero similar
a Windows y Mac OS,

499
00:22:48,660 --> 00:22:51,150
al parecer nada sucedió
y generalmente eso es bueno.

500
00:22:51,150 --> 00:22:52,900
Porque si no ven un
mensaje de error,

501
00:22:52,900 --> 00:22:55,740
significa que la computadora
no tiene nada de qué quejarse.

502
00:22:55,740 --> 00:22:57,480
Entonces
¿qué hago a continuación?

503
00:22:57,480 --> 00:22:59,020
Bien, observen lo siguiente.

504
00:22:59,020 --> 00:23:03,800
Si abro mi explorador de archivos,
veo que aparecieron un par de cosas.

505
00:23:03,800 --> 00:23:06,810
Hace unos minutos no había nada,
excepto mi espacio de trabajo.

506
00:23:06,810 --> 00:23:10,980
Tal vez tiene sentido que ahora
existe hello.c porque hice eso.

507
00:23:10,980 --> 00:23:12,690
Fui a archivo, guardar.

508
00:23:12,690 --> 00:23:16,800
Pero, ¿qué creen que es a.out?

509
00:23:16,800 --> 00:23:20,100
Parece que es otro archivo,
pero yo no escribí esa palabra.

510
00:23:20,100 --> 00:23:21,264
¿Sí?

511
00:23:21,264 --> 00:23:22,162
PÚBLICO: [INAUDIBLE]

512
00:23:22,162 --> 00:23:23,120
DAVID: Díganlo otra vez.

513
00:23:23,120 --> 00:23:24,210
PÚBLICO: [INAUDIBLE]

514
00:23:24,210 --> 00:23:25,293
DAVID: ¿Otro archivo?

515
00:23:25,293 --> 00:23:27,724
PÚBLICO: Un archivo ejecutable.

516
00:23:27,724 --> 00:23:29,640
DAVID: Es lo que
puedo ejecutar, exacto.

517
00:23:29,640 --> 00:23:34,200
Entonces, cuando ejecuto el
compilador Clang en mi código fuente,

518
00:23:34,200 --> 00:23:37,560
prometí en la diapositiva anterior,
que se vería el código máquina

519
00:23:37,560 --> 00:23:38,432
de ceros y unos.

520
00:23:38,432 --> 00:23:40,890
Sería un poco molesto si esto,
literalmente, generara un código

521
00:23:40,890 --> 00:23:43,306
de ceros y unos en la pantalla,
porque eso no me resulta útil

522
00:23:43,306 --> 00:23:45,700
y la computadora
no necesita verlo en la pantalla.

523
00:23:45,700 --> 00:23:49,860
Así que esos ceros y unos se guardan en
un archivo llamado a.out, por convención.

524
00:23:49,860 --> 00:23:53,027
a es la primera letra del
alfabeto y out es la salida.

525
00:23:53,027 --> 00:23:55,110
Aunque su origen es
un poco más elegante que eso.

526
00:23:55,110 --> 00:23:57,030
Pero eso es todo, solo el nombre
predeterminado del archivo.

527
00:23:57,030 --> 00:23:58,530
Entonces
¿Cómo lo ejecuto?

528
00:23:58,530 --> 00:24:01,080
Bueno, en una Mac o en
una PC, generalmente le daría clic.

529
00:24:01,080 --> 00:24:04,560
Pero no lo haré así en un
entorno de línea de comando.

530
00:24:04,560 --> 00:24:08,580
Y esa palabra, entorno de línea
de comandos, o CLI, su acrónimo.

531
00:24:08,580 --> 00:24:10,920
Literalmente tengo que hacer
todo en la línea de comandos

532
00:24:10,920 --> 00:24:13,110
escribiendo los
comandos con mi teclado.

533
00:24:13,110 --> 00:24:17,370
Y la manera de hacerlo
es la siguiente, ./a.out.

534
00:24:17,370 --> 00:24:21,040
El punto significa la búsqueda en mi
directorio actual, donde sea que esté,

535
00:24:21,040 --> 00:24:22,285
por ejemplo,
en mi área de trabajo.

536
00:24:22,285 --> 00:24:25,450
La diagonal solo es un separador
que tal vez ya han visto en Mac y PC

537
00:24:25,450 --> 00:24:27,220
para separar los
nombres de las carpetas.

538
00:24:27,220 --> 00:24:28,870
y a.out es el nombre del programa.

539
00:24:28,870 --> 00:24:33,910
Y ahora, cuando presiono Enter, es
como si hiciera doble clic sobre un icono

540
00:24:33,910 --> 00:24:38,470
en una interfaz gráfica moderna,
como la de Mac OS o Windows.

541
00:24:38,470 --> 00:24:41,830
Pero yo diría que este programa
tiene algunos defectos, ¿o no?

542
00:24:41,830 --> 00:24:45,637
Mi pantalla, antes que
parecer novedosa para la mayoría,

543
00:24:45,637 --> 00:24:47,470
se ve un poco tonta,
por el momento.

544
00:24:47,470 --> 00:24:48,340
¿Por qué?

545
00:24:48,340 --> 00:24:49,390
Estéticamente.

546
00:24:49,390 --> 00:24:50,086
¿Sí?

547
00:24:50,086 --> 00:24:52,030
PÚBLICO: Está en la misma línea que hello,
world [INAUDIBLE] espacio de trabajo.

548
00:24:52,030 --> 00:24:52,780
DAVID: Sí.

549
00:24:52,780 --> 00:24:56,080
Hello, world, en blanco está en línea con
la palabra clave en el espacio de trabajo.

550
00:24:56,080 --> 00:24:59,434
Y el espacio de trabajo solo
me recuerda cada línea en donde estoy.

551
00:24:59,434 --> 00:25:01,850
Porque, otra vez, justo ahora
no es gráfico, es textual.

552
00:25:01,850 --> 00:25:05,080
Así que literalmente veo en azul
dónde estoy, en cual carpeta me encuentro.

553
00:25:05,080 --> 00:25:07,500
Y francamente,
esto me molesta.

554
00:25:07,500 --> 00:25:10,690
Soy un poco analítico
y no me gusta cómo luce.

555
00:25:10,690 --> 00:25:12,100
Y podría decirse que es un error.

556
00:25:12,100 --> 00:25:12,850
Pero, ¿por qué ocurre esto?

557
00:25:12,850 --> 00:25:16,570
Bueno, simplemente porque
la computadora me interpretó literalmente.

558
00:25:16,570 --> 00:25:19,630
Aquí, en mi código fuente,
noten que de manera deliberada

559
00:25:19,630 --> 00:25:22,750
cometí este error o inconsistencia
con lo que vimos hace un momento.

560
00:25:22,750 --> 00:25:24,400
Omití algo de esta línea.

561
00:25:24,400 --> 00:25:26,230
¿Qué fue eso?

562
00:25:26,230 --> 00:25:30,880
Sí, la n con la diagonal inversa.

563
00:25:30,880 --> 00:25:36,190
Entonces, ¿cuál es
la parte que sirve?

564
00:25:36,190 --> 00:25:39,830
Bueno, la n con la diagonal inversa
es una manera explícita de decir

565
00:25:39,830 --> 00:25:42,400
hey computadora,
inserta una línea nueva aquí.

566
00:25:42,400 --> 00:25:44,230
Presiona la tecla Enter aquí.

567
00:25:44,230 --> 00:25:49,060
Y se escribe como n diagonal
inversa solo porque al hacerlo

568
00:25:49,060 --> 00:25:52,807
se ve desordenado y es el tipo de cosas
poco obvias que se supone que ocurren.

569
00:25:52,807 --> 00:25:54,640
Entonces los programadores,
decidieron hace años, ya saben,

570
00:25:54,640 --> 00:25:58,780
que expresaremos la noción
de presionar Enter simbólicamente

571
00:25:58,780 --> 00:25:59,560
con la diagonal inversa n.

572
00:25:59,560 --> 00:26:00,060
Eso es todo.

573
00:26:00,060 --> 00:26:04,890
Ahora, si guardo el archivo, lo cual
puedo hacer con el comando s,

574
00:26:04,890 --> 00:26:07,750
o Control+s, e incluso se puede ser más
explícito e ir a Archivo y Guardar,

575
00:26:07,750 --> 00:26:13,930
igual que en sus computadoras,
y ahora ejecuto ./a.out, Enter...

576
00:26:13,930 --> 00:26:15,520
Diablos.

577
00:26:15,520 --> 00:26:17,670
¿Qué salió mal?

578
00:26:17,670 --> 00:26:19,120
Ah sí, tengo que volver a compilar.

579
00:26:19,120 --> 00:26:20,320
Entonces de nuevo,
este es un proceso.

580
00:26:20,320 --> 00:26:21,200
Guardé el archivo.

581
00:26:21,200 --> 00:26:22,450
Mi código fuente ahora es correcto.

582
00:26:22,450 --> 00:26:25,671
Pero mi código fuente está desactualizado
porque no lo he compilado de nuevo.

583
00:26:25,671 --> 00:26:28,420
A final de cuentas la computadora
es un dispositivo bastante tonto.

584
00:26:28,420 --> 00:26:31,169
Aunque sea muy rápida,
solo hará lo que le diga.

585
00:26:31,169 --> 00:26:35,560
Así es que, mejor ponemos
de nuevo clang hello.c.

586
00:26:35,560 --> 00:26:36,700
Parece que no ocurre nada.

587
00:26:36,700 --> 00:26:38,740
Pero es posible
que cambió a.out.

588
00:26:38,740 --> 00:26:42,700
De hecho, si pongo ./a.out,
ahora puedo ver hello, world.

589
00:26:42,700 --> 00:26:46,690
Aparentemente coloca un salto
de línea invisible en la pantalla,

590
00:26:46,690 --> 00:26:50,450
pero ahora, todo se ve
un poco más ordenado.

591
00:26:50,450 --> 00:26:53,950
Pero clang hello.c nos da un
nombre de archivo bastante tonto.

592
00:26:53,950 --> 00:26:57,400
Sería genial si pudiera llamar
a mi programa hello o hello, world,

593
00:26:57,400 --> 00:26:58,420
o algo por el estilo.

594
00:26:58,420 --> 00:27:00,332
Y podemos hacerlo
en un par de maneras.

595
00:27:00,332 --> 00:27:02,290
Haré de nuevo un acercamiento.

596
00:27:02,290 --> 00:27:04,581
Voy a limpiar la pantalla,
solo para mantener todo ordenado.

597
00:27:04,581 --> 00:27:08,140
Y parece que puedo poner
comandos como clang y otros

598
00:27:08,140 --> 00:27:11,170
que después veremos con los
argumentos de la línea de comandos.

599
00:27:11,170 --> 00:27:16,060
De hecho puedo especificar,
clang, en vez de poner solo hello.c

600
00:27:16,060 --> 00:27:18,310
como tu entrada,
también haz esto.

601
00:27:18,310 --> 00:27:20,920
Que la salida sea
un archivo llamado hello.

602
00:27:20,920 --> 00:27:22,392
Y esto varía según el programa.

603
00:27:22,392 --> 00:27:24,100
clang no es
el único programa que

604
00:27:24,100 --> 00:27:25,840
veremos en esta
ventana de terminal azul.

605
00:27:25,840 --> 00:27:30,040
Esto significa, hey clang,
haz un archivo de salida llamado hello

606
00:27:30,040 --> 00:27:33,040
y toma como entrada
el archivo anterior, hello.c.

607
00:27:33,040 --> 00:27:33,680
¿Por qué?

608
00:27:33,680 --> 00:27:37,210
Bueno, los humanos decidieron que O
sería la primera letra de la palabra salida.

609
00:27:37,210 --> 00:27:39,850
Y que -o sería una
linda forma de decir salida.

610
00:27:39,850 --> 00:27:42,640
Así que -o hello significa
la salida un archivo llamado hello

611
00:27:42,640 --> 00:27:44,950
en vez de la predeterminada a.out.

612
00:27:44,950 --> 00:27:49,360
Otra vez parece que nada sucede, pero si
me alejo y veo mi explorador de archivos,

613
00:27:49,360 --> 00:27:53,710
notarán que ahora tengo
el antiguo a.out y además hello

614
00:27:53,710 --> 00:27:55,330
en mi código fuente.

615
00:27:55,330 --> 00:28:02,770
Por intuición, ¿cómo ejecuto
esta nueva versión llamada hello?

616
00:28:02,770 --> 00:28:06,000
Sería ./ porque
el punto significa "aquí"

617
00:28:06,000 --> 00:28:08,620
y la diagonal separa
el nombre del archivo.

618
00:28:08,620 --> 00:28:11,740
Hello, enter,
es exactamente lo mismo.

619
00:28:11,740 --> 00:28:14,110
Ahora seguiré abriendo y
cerrando el explorador de archivos

620
00:28:14,110 --> 00:28:16,026
para que podamos ver
las cosas gráficamente.

621
00:28:16,026 --> 00:28:17,290
Pero eso no es necesario.

622
00:28:17,290 --> 00:28:19,660
Resulta que en un entorno
de líneas de comandos

623
00:28:19,660 --> 00:28:21,160
se tienen muchos comandos.

624
00:28:21,160 --> 00:28:26,080
Por ejemplo, puedo escribir ls,
que es una manera breve de decir lista.

625
00:28:26,080 --> 00:28:29,586
Hey computadora, lista todos
los archivos de la carpeta actual.

626
00:28:29,586 --> 00:28:31,210
La carpeta actual
se llama espacio de trabajo,

627
00:28:31,210 --> 00:28:33,790
por eso la mantengo
marcada en azul.

628
00:28:33,790 --> 00:28:37,780
Y ahora verán tres cosas, a.out
con asterisco, hello con asterisco,

629
00:28:37,780 --> 00:28:38,320
y hello.c.

630
00:28:38,320 --> 00:28:40,030
Y también están
codificados por color.

631
00:28:40,030 --> 00:28:42,880
En la mayoría de
los entornos de texto,

632
00:28:42,880 --> 00:28:47,754
si lo configuran así, cualquier
programa que esté resaltado en verde

633
00:28:47,754 --> 00:28:50,462
y tenga un asterisco al lado,
significa que es ejecutable.

634
00:28:50,462 --> 00:28:51,380
Pueden ejecutarlo.

635
00:28:51,380 --> 00:28:54,880
No con doble clic, sino escribiendo
punto, diagonal, nombre del programa.

636
00:28:54,880 --> 00:28:58,030
Cualquier cosa que esté en blanco aquí
será un archivo de texto, como hello.c.

637
00:28:58,030 --> 00:28:59,350
Solo tengo uno de esos.

638
00:28:59,350 --> 00:29:04,280
Si tengo carpetas,
vería así sus nombres.

639
00:29:04,280 --> 00:29:07,060
Y puedo crear carpetas
como en Mac OS y Windows

640
00:29:07,060 --> 00:29:08,330
en dos maneras diferentes.

641
00:29:08,330 --> 00:29:12,490
De hecho, puedo ir con mi ratón
hasta mi explorador de archivos.

642
00:29:12,490 --> 00:29:15,580
Puedo dar Control, clic,
o dar allí un clic derecho,

643
00:29:15,580 --> 00:29:18,160
desplazarme hasta el final
y elegir Nueva carpeta.

644
00:29:18,160 --> 00:29:20,910
Y cuando lo haga
verán la nueva carpeta.

645
00:29:20,910 --> 00:29:25,080
Tal vez quiero aplicarlo para
pset1 one, serie de problemas uno,

646
00:29:25,080 --> 00:29:26,010
y presiono Enter.

647
00:29:26,010 --> 00:29:29,420
Y ahora tengo una
carpeta llamada pset1.

648
00:29:29,420 --> 00:29:33,690
Puedo verla en mi entorno de línea
de comandos si tecleo de nuevo ls, Enter.

649
00:29:33,690 --> 00:29:36,840
Y ahora noten que tengo
el mismo par de programas ejecutables

650
00:29:36,840 --> 00:29:38,400
que en el mismo
archivo de texto, hello.c

651
00:29:38,400 --> 00:29:41,010
y un directorio
en azul llamado pset1.

652
00:29:41,010 --> 00:29:45,750
Y la diagonal solo sirve para indicar,
hey, humano, soy una carpeta.

653
00:29:45,750 --> 00:29:48,120
¿Cómo puedo abrir pset1?

654
00:29:48,120 --> 00:29:51,300
Bueno, en Mac OS y Windows
podrían hacer doble clic

655
00:29:51,300 --> 00:29:53,680
para expandir las cosas
y mostrar lo que hay adentro.

656
00:29:53,680 --> 00:29:55,390
Pero una vez más, se trata
de un entorno textual.

657
00:29:55,390 --> 00:30:00,770
Así que dejémoslo, vayamos abajo
y cambiemos a pset1 como sigue.

658
00:30:00,770 --> 00:30:03,750
cd es otro comando
en un entorno de Linux.

659
00:30:03,750 --> 00:30:06,750
pero Linux es solo otro sistema
operativo, como Mac OS o Windows,

660
00:30:06,750 --> 00:30:08,970
que ejecutamos
desde la nube.

661
00:30:08,970 --> 00:30:12,660
Y si pongo cd pset1,
con o sin diagonal,

662
00:30:12,660 --> 00:30:17,890
no importa, y presiono
Enter, mi cursor cambió.

663
00:30:17,890 --> 00:30:20,250
Y mi cursor corresponde
a las palabras que están en la pantalla

664
00:30:20,250 --> 00:30:21,800
solo para recordarme
en qué punto me encuentro.

665
00:30:21,800 --> 00:30:23,730
En azul decía anteriormente
espacio de trabajo,

666
00:30:23,730 --> 00:30:27,510
ahora dice espacio de trabajo/pset1
porque he aplicado el equivalente

667
00:30:27,510 --> 00:30:29,970
de hacer doble clic
sobre pset1 con mi teclado,

668
00:30:29,970 --> 00:30:32,610
para abrirlo y entrar en él.

669
00:30:32,610 --> 00:30:34,260
Haré una suposición.

670
00:30:34,260 --> 00:30:38,520
Si escribo ls dentro de mi
directorio pset1 y presiono Enter,

671
00:30:38,520 --> 00:30:40,260
¿qué deberíamos ver?

672
00:30:40,260 --> 00:30:43,080
Con suerte, nada, porque sería
algo raro si todo lo que hice

673
00:30:43,080 --> 00:30:45,330
fue crear una carpeta y
de repente hubiera algo en su interior.

674
00:30:45,330 --> 00:30:47,190
De hecho no hay nada en ella.

675
00:30:47,190 --> 00:30:50,880
Escribir ls, Enter no muestra nada,
lo que significa que no hay nada adentro.

676
00:30:50,880 --> 00:30:54,010
Sin embargo, si decido que
tiene un error, me estoy adelantando,

677
00:30:54,010 --> 00:30:55,110
puedo volver

678
00:30:55,110 --> 00:30:58,710
y podría no ser evidente, pero "cd .."

679
00:30:58,710 --> 00:31:03,540
significa retroceder un directorio
o técnicamente ir a la base.

680
00:31:03,540 --> 00:31:07,110
Pueden pensar en la estructura
de carpetas de su Mac o PC y en los IDE

681
00:31:07,110 --> 00:31:08,100
como en un árbol,

682
00:31:08,100 --> 00:31:09,400
un árbol genealógico,

683
00:31:09,400 --> 00:31:13,500
Y simplemente fui hacía el origen
del espacio de trabajo llamado pset1.

684
00:31:13,500 --> 00:31:17,820
Entonces, cd .. los lleva
de regreso, si lo ven así, o los lleva

685
00:31:17,820 --> 00:31:20,230
si así lo prefieren, al modelo
mental de un árbol genealógico.

686
00:31:20,230 --> 00:31:24,270
Si ahora presiono Enter, mi cursor
regresa al espacio de trabajo.

687
00:31:24,270 --> 00:31:27,570
Si escribo ls, me siento cómodo
de nuevo, puedo ver lo que ya sabemos.

688
00:31:27,570 --> 00:31:29,370
Y si deseo eliminar
ese directorio,

689
00:31:29,370 --> 00:31:34,770
simplemente escribo rmdir,
para eliminar el directorio pset1,

690
00:31:34,770 --> 00:31:35,580
y desaparece.

691
00:31:35,580 --> 00:31:37,650
Y confirmo que ls tuvo mucho que ver.

692
00:31:37,650 --> 00:31:40,440
Así que, en resumen, esta es
la forma textual de hacer cosas

693
00:31:40,440 --> 00:31:45,030
que tal vez han hecho
por años en su Mac, PC o teléfono

694
00:31:45,030 --> 00:31:47,060
todos los días.

695
00:31:47,060 --> 00:31:47,730
Bien.

696
00:31:47,730 --> 00:31:50,160
Nada de esto es
intelectualmente interesante.

697
00:31:50,160 --> 00:31:52,662
Ahora que hemos aprendido
cómo crear archivos y carpetas,

698
00:31:52,662 --> 00:31:54,870
profundicemos
en algunos de los códigos

699
00:31:54,870 --> 00:31:57,730
y en las ideas con las que
resolvemos los problemas.

700
00:31:57,730 --> 00:32:00,420
Este primer programa
realmente no hizo mucho

701
00:32:00,420 --> 00:32:02,727
aunque al parecer expresó una idea.

702
00:32:02,727 --> 00:32:04,560
Y comenzaremos dando por hecho,

703
00:32:04,560 --> 00:32:07,020
más aún, lo que
realmente es una función.

704
00:32:07,020 --> 00:32:09,930
Y tal vez, solo para aclarar
este punto, haré lo siguiente.

705
00:32:09,930 --> 00:32:13,020
Cambiaré la pantalla
anterior a un lienzo en blanco.

706
00:32:13,020 --> 00:32:15,550
Es decir, todos los círculos
que dibuje anteriormente.

707
00:32:15,550 --> 00:32:20,020
Necesito un voluntario, ¿tal vez
a cambio de una pelotita para el estrés?

708
00:32:20,020 --> 00:32:22,770
OK, eso fue rápido, ven acá.

709
00:32:22,770 --> 00:32:24,190
¿Cómo te llamas?

710
00:32:24,190 --> 00:32:24,962
SAM: Sam.

711
00:32:24,962 --> 00:32:25,920
DAVID: Muy bien.

712
00:32:25,920 --> 00:32:31,650
Sam, aquí tenemos
una etiqueta para ti.

713
00:32:31,650 --> 00:32:34,170
Pero en vez de llamarte Sam,

714
00:32:34,170 --> 00:32:37,852
te llamaremos por el momento printf.

715
00:32:37,852 --> 00:32:39,810
Así que si no te importa,
di hola, mi nombre es printf.

716
00:32:39,810 --> 00:32:40,920
SAM: Hola, mi nombre es printf.

717
00:32:40,920 --> 00:32:41,640
DAVID: OK, gracias.

718
00:32:41,640 --> 00:32:42,480
Pon eso donde quieras.

719
00:32:42,480 --> 00:32:45,960
Muy bien, quédate allí un momento.

720
00:32:45,960 --> 00:32:49,750
Mientras, yo seré el
programador en mi computadora

721
00:32:49,750 --> 00:32:53,460
y mi objetivo es, simplemente,
imprimir en la pantalla hello, world.

722
00:32:53,460 --> 00:32:55,489
Ahora que he programado durante años

723
00:32:55,489 --> 00:32:57,780
tengo varias pantallas
acumuladas a lo largo de años,

724
00:32:57,780 --> 00:33:01,680
Y no me importa cómo
las palabras que escribo en mi programa

725
00:33:01,680 --> 00:33:03,000
salen en la pantalla.

726
00:33:03,000 --> 00:33:07,740
Quiero delegar esa
funcionalidad en alguien

727
00:33:07,740 --> 00:33:08,280
o en algo más.

728
00:33:08,280 --> 00:33:10,860
Y afortunadamente Sam ha
programado durante algún tiempo,

729
00:33:10,860 --> 00:33:14,490
sabe cómo hablarle o imprimir cosas
en las pantallas de la computadora,

730
00:33:14,490 --> 00:33:19,020
y así puedo externar
la funcionalidad que quiero usar.

731
00:33:19,020 --> 00:33:21,780
Pero no me interesa
cómo se implementará

732
00:33:21,780 --> 00:33:26,460
o cómo lo aplique Sam,
simplemente llamo a Sam

733
00:33:26,460 --> 00:33:27,400
 y le pido que haga algo.

734
00:33:27,400 --> 00:33:31,350
Así que en este caso,
Sam, ahora eres printf.

735
00:33:31,350 --> 00:33:34,500
Así que tomaré un
pedazo de papel y les diré,

736
00:33:34,500 --> 00:33:39,270
si no les importa,
para asignar la entrada,

737
00:33:39,270 --> 00:33:43,270
le daré a Sam un trozo de papel
que dice, hello, world.

738
00:33:43,270 --> 00:33:46,172
Y si no te molesta, ¿puedes
imprimirlo en la pantalla

739
00:33:46,172 --> 00:33:47,380
ya que, de hecho, eres printf.

740
00:33:47,380 --> 00:33:49,630
Y puedes hacerlo con solo
poner tu dedo en la pantalla.

741
00:33:49,630 --> 00:33:52,110

742
00:33:52,110 --> 00:33:53,570
Así que, soy el
programa de computadora,

743
00:33:53,570 --> 00:33:55,940
no tengo idea de
cómo funciona la impresión,

744
00:33:55,940 --> 00:33:58,100
solo sé que escribí
una línea de código,

745
00:33:58,100 --> 00:33:59,680
ejecuté el programa,

746
00:33:59,680 --> 00:34:01,470
printf está en marcha,

747
00:34:01,470 --> 00:34:03,480
está haciendo su trabajo

748
00:34:03,480 --> 00:34:04,670
y perfecto.

749
00:34:04,670 --> 00:34:07,400
Sam, vuelve aquí.

750
00:34:07,400 --> 00:34:10,400
Y ahora Sam terminó
de ejecutarlo, si les parece bien.

751
00:34:10,400 --> 00:34:12,019
Muchas gracias.

752
00:34:12,019 --> 00:34:14,810
Y esa fue una manera
ridículamente extensa de

753
00:34:14,810 --> 00:34:18,734
mostrar que las funciones no son
intelectualmente interesantes.

754
00:34:18,734 --> 00:34:20,900
Es solo empaquetar
estas funcionalidades

755
00:34:20,900 --> 00:34:24,150
que no necesariamente debo saber
o que me importe cómo funciona.

756
00:34:24,150 --> 00:34:25,610
Pero quiero completar el trabajo.

757
00:34:25,610 --> 00:34:26,840
Y de hecho,
podemos hacer un trabajo más.

758
00:34:26,840 --> 00:34:29,131
Si no les importa cambiar
su nombre solo por un momento.

759
00:34:29,131 --> 00:34:31,519
¿Qué tal a cambio de
dos pelotas para el estrés?

760
00:34:31,519 --> 00:34:36,830
Así que ahora voy a pedirles que
cambien su nombre por get_string, porque

761
00:34:36,830 --> 00:34:39,530
ocurre que,
en el mundo de las computadoras...

762
00:34:39,530 --> 00:34:42,530
técnicamente, esto no ayuda
a ponerlo en marcha, pero está bien.

763
00:34:42,530 --> 00:34:44,810
Así que, en el mundo
de las computadoras hay muchas

764
00:34:44,810 --> 00:34:48,380
otras funciones que pueden utilizar,
y algunas son específicas para CS50.

765
00:34:48,380 --> 00:34:50,539
Pero la mayoría no lo son.

766
00:34:50,539 --> 00:34:54,002
Y, de hecho, si abro esta lista,

767
00:34:54,002 --> 00:34:56,960
algunas de las funciones
que utilizaremos y daremos por hecho

768
00:34:56,960 --> 00:34:57,710
son estas.

769
00:34:57,710 --> 00:35:01,670
get_char para obtener un carácter, get_int
para obtener un entero, get_string

770
00:35:01,670 --> 00:35:03,506
para obtener una cadena o una frase,

771
00:35:03,506 --> 00:35:05,130
get_float para algo incluso distinto,

772
00:35:05,130 --> 00:35:07,105
y aún no sé cómo funcionan.

773
00:35:07,105 --> 00:35:09,980
Realmente no sé cómo trabajan los
teclados o de dónde vienen las entradas.

774
00:35:09,980 --> 00:35:11,530
Pero afortunadamente,
alguien más lo hizo.

775
00:35:11,530 --> 00:35:14,020
Sam, en este caso, implementó
el comando get_string.

776
00:35:14,020 --> 00:35:15,770
Y ahora, si no te importa, Sam,

777
00:35:15,770 --> 00:35:18,500
voy a escribir otro
programa contigo justo allí.

778
00:35:18,500 --> 00:35:20,570
Y lo veremos
en lugar de esto.

779
00:35:20,570 --> 00:35:27,210
Voy crear un nuevo archivo
al que llamaré string.c

780
00:35:27,210 --> 00:35:31,280
luego pondré #include <stdio.h>,

781
00:35:31,280 --> 00:35:34,310
Int main(void), el cual solo
copiaremos y pegaremos del anterior.

782
00:35:34,310 --> 00:35:37,010
Pero en lugar de
solo escribir hello, world,

783
00:35:37,010 --> 00:35:44,870
voy a poner
string s = get_string("Name: ");

784
00:35:44,870 --> 00:35:50,987
Y luego escribiré
printf("hello, %...

785
00:35:50,987 --> 00:35:54,920
printf("hello, %s\ n", s);

786
00:35:54,920 --> 00:35:56,067
¿Qué ocurre entonces?

787
00:35:56,067 --> 00:35:57,650
Regresaremos
a la línea 6 en un momento.

788
00:35:57,650 --> 00:36:01,040
Pero ahora la línea 5 está haciendo
dos cosas en el lado izquierdo,

789
00:36:01,040 --> 00:36:04,370
está declarando una
variable s, la cual

790
00:36:04,370 --> 00:36:06,907
almacenará, aparentemente,
¿qué tipo de datos?

791
00:36:06,907 --> 00:36:09,740
Una cadena, que puede ser una palabra,
una frase, un párrafo o lo que sea,

792
00:36:09,740 --> 00:36:11,510
son caracteres del teclado.

793
00:36:11,510 --> 00:36:13,149
¿Y qué va dentro de s?

794
00:36:13,149 --> 00:36:16,190
Cuando hablamos antes sobre las variables,
pusimos dentro de otra variable

795
00:36:16,190 --> 00:36:18,260
llamada i, el número 0.

796
00:36:18,260 --> 00:36:20,476
Aquí, en el lado
derecho del signo igual,

797
00:36:20,476 --> 00:36:23,600
ponemos en cambio el nombre
de una función, lo cual es interesante,

798
00:36:23,600 --> 00:36:27,471
porque antes, cuando Sam era
una función llamada printf, hizo algo

799
00:36:27,471 --> 00:36:29,720
y después volvió a mí,
pero no me dio nada.

800
00:36:29,720 --> 00:36:31,635
Solo le di las gracias y seguí adelante.

801
00:36:31,635 --> 00:36:34,010
Pero en este caso,
quiero que Sam simplemente

802
00:36:34,010 --> 00:36:37,190
vaya hacia al público
con esta pluma y un trozo de papel,

803
00:36:37,190 --> 00:36:38,830
que vaya y me consiga una cadena.

804
00:36:38,830 --> 00:36:41,090
Por favor, consigue
el nombre de una persona,

805
00:36:41,090 --> 00:36:41,960
cualquiera que desees.

806
00:36:41,960 --> 00:36:44,610
Una vez más, no tengo idea de
cómo se implementa esto.

807
00:36:44,610 --> 00:36:48,380
Le pudo tomar a Sam 5 líneas de código
o 20 líneas de código, o 100 para

808
00:36:48,380 --> 00:36:51,217
respaldar el proceso de obtener
la entrada de un humano.

809
00:36:51,217 --> 00:36:53,300
Pero lo que es diferente
en el caso de esta función

810
00:36:53,300 --> 00:36:57,710
es que ahora volverá a mí
y no solo terminará de ejecutarlo,

811
00:36:57,710 --> 00:37:00,020
de hecho me devolverá algo

812
00:37:00,020 --> 00:37:02,103
y empezaremos a llamar
a esto, gracias, Sam,

813
00:37:02,103 --> 00:37:06,200
un valor de retorno,
el nombre de Katrina.

814
00:37:06,200 --> 00:37:09,590
Y así me entregó lo
que llamaremos un valor de retorno.

815
00:37:09,590 --> 00:37:12,000
A continuación haré algo con esto.

816
00:37:12,000 --> 00:37:14,330
Y, ¿cómo conecto esto a mi cadena?

817
00:37:14,330 --> 00:37:16,940
Lo hago con esta línea 6 que tengo aquí.

818
00:37:16,940 --> 00:37:20,540
Le digo a printf,
no solamente hello, sino hello, %s,

819
00:37:20,540 --> 00:37:25,520
y %s es solo una forma críptica
de decir, pon una cadena aquí.

820
00:37:25,520 --> 00:37:27,200
¿Cuál cadena quiero añadir?

821
00:37:27,200 --> 00:37:29,990
Bueno, inmediatamente
después de la coma, noten que

822
00:37:29,990 --> 00:37:34,850
mencioné el nombre
de la misma variable, s, en la cual

823
00:37:34,850 --> 00:37:38,030
guardé lo que Sam me entregó.

824
00:37:38,030 --> 00:37:41,270
Y así, para cada función que
escribimos, utilizamos a un voluntario real.

825
00:37:41,270 --> 00:37:42,603
Pero eso es todo lo que ocurre.

826
00:37:42,603 --> 00:37:45,110
No tengo idea de a quién
fue a buscar Sam.

827
00:37:45,110 --> 00:37:47,930
No tengo la menor idea
de si él escribirá

828
00:37:47,930 --> 00:37:51,920
con cursivas
o sin cursivas en la pantalla.

829
00:37:51,920 --> 00:37:54,000
Solo sé que él
era capaz de hacerlo.

830
00:37:54,000 --> 00:37:57,140
Así que, tal vez podríamos
darle a Sam una ronda de aplausos.

831
00:37:57,140 --> 00:37:59,600
Gracias.

832
00:37:59,600 --> 00:38:04,610
Entonces, basta con decirlo,
hay otras funciones, no solo get_string.

833
00:38:04,610 --> 00:38:07,430
Pero si quieren obtener un entero,
hay otra función para ello.

834
00:38:07,430 --> 00:38:10,850
Si quieren obtener un carácter único,
get_char es otra función que sirve.

835
00:38:10,850 --> 00:38:12,350
Pero también hay más cosas aquí,

836
00:38:12,350 --> 00:38:16,680
double, float y long_long,
y lo que sea que signifiquen.

837
00:38:16,680 --> 00:38:20,840
Resulta que para las computadoras,
especialmente con lenguajes como C,

838
00:38:20,840 --> 00:38:24,680
necesitamos ser súper precisos
en cuanto al tipo de datos

839
00:38:24,680 --> 00:38:26,600
que se almacenarán en ellas.

840
00:38:26,600 --> 00:38:30,500
Y se tiene que especificar por adelantado,
esta es una cadena, este es un entero,

841
00:38:30,500 --> 00:38:34,070
esto es algo con un punto
decimal, no solo un entero.

842
00:38:34,070 --> 00:38:37,130
Y para continuar
propondremos un ejemplo

843
00:38:37,130 --> 00:38:39,410
como el siguiente, esta vez
utilizaremos un número entero.

844
00:38:39,410 --> 00:38:42,050
Voy a volver al IDE.

845
00:38:42,050 --> 00:38:47,450
Voy a crear un
nuevo archivo llamado int.c.

846
00:38:47,450 --> 00:38:51,710
y abriré los archivos
anteriores, #include <stdio.h>,

847
00:38:51,710 --> 00:38:53,302
int main void

848
00:38:53,302 --> 00:38:55,010
y esta vez pondré

849
00:38:55,010 --> 00:38:59,870
int  i = get_string(" integer: ");

850
00:38:59,870 --> 00:39:01,220
Y después printf...

851
00:39:01,220 --> 00:39:03,860
Qué tal solo
printf("hello, %...

852
00:39:03,860 --> 00:39:05,690
no s, porque el comando s
es para una cadena,

853
00:39:05,690 --> 00:39:11,600
sino printf("hello, %i\ n"),
donde i es para los enteros.

854
00:39:11,600 --> 00:39:14,900
Esto luce como un programa
completo, aunque no lo hemos utilizado,

855
00:39:14,900 --> 00:39:18,800
perdón, hay un error en get_int.

856
00:39:18,800 --> 00:39:21,637
Entonces, esto parece un programa
completo, aunque mucha de la sintaxis

857
00:39:21,637 --> 00:39:22,470
puede ser nueva para ustedes.

858
00:39:22,470 --> 00:39:24,360
Ahora tratemos de ejecutarlo.

859
00:39:24,360 --> 00:39:26,400
¿Cómo ejecuto éste programa?

860
00:39:26,400 --> 00:39:27,810
Aún no puedo ejecutarlo.

861
00:39:27,810 --> 00:39:29,690
¿Cuál es el primer paso?

862
00:39:29,690 --> 00:39:31,160
Sí, primero tengo que compilarlo.

863
00:39:31,160 --> 00:39:33,580
¿Y cómo lo compilo?

864
00:39:33,580 --> 00:39:34,790
Sí, con clang,

865
00:39:34,790 --> 00:39:35,870
puedo poner -o,

866
00:39:35,870 --> 00:39:39,560
puedo llamarlo int, porque deseo
que el nombre del programa sea int.

867
00:39:39,560 --> 00:39:40,960
Francamente, esto es molesto.

868
00:39:40,960 --> 00:39:44,120
No quiero escribir todo el tiempo
clang, -o, nombre del archivo.

869
00:39:44,120 --> 00:39:45,487
Solo quiero hacer el programa.

870
00:39:45,487 --> 00:39:46,820
No quiero preocuparme por esto.

871
00:39:46,820 --> 00:39:48,620
Y resulta que hay
formas para lograrlo.

872
00:39:48,620 --> 00:39:53,510
Porque en el IDE está instalado
un comando muy popular que se llama

873
00:39:53,510 --> 00:39:54,320
make.

874
00:39:54,320 --> 00:39:56,720
Y make les permite
escribir solamente esto

875
00:39:56,720 --> 00:39:57,920
make int.

876
00:39:57,920 --> 00:39:59,075
No tienen que especificar .c.

877
00:39:59,075 --> 00:40:02,340
Solamente deben especificar
el inicio del nombre del archivo.

878
00:40:02,340 --> 00:40:03,980
De modo que si esto
es int.c, ustedes escriben int,

879
00:40:03,980 --> 00:40:05,420
si es hello.c,
entonces escriben hello.

880
00:40:05,420 --> 00:40:07,460
Y solo tienen que escribir make int.

881
00:40:07,460 --> 00:40:09,140
Y make será un programa diferente,

882
00:40:09,140 --> 00:40:11,150
técnicamente no se trata de un compilador,

883
00:40:11,150 --> 00:40:13,910
pero es un programa que
sabe cómo utilizar un compilador.

884
00:40:13,910 --> 00:40:18,980
Y cuando presionamos Enter, vean
la larga y loca salida que arroja.

885
00:40:18,980 --> 00:40:23,450
Incluye la palabra clang, pero luego
incluye también todos estos argumentos

886
00:40:23,450 --> 00:40:26,690
de línea de comandos que nunca
querrán recordar o tener que

887
00:40:26,690 --> 00:40:27,859
escribirlos ustedes mismos.

888
00:40:27,859 --> 00:40:29,150
Sería increíblemente tedioso.

889
00:40:29,150 --> 00:40:32,060
Pero eso es simple, porque
nosotros hemos preconfigurado

890
00:40:32,060 --> 00:40:34,790
el IDE para que se configure
el clang de cierto modo

891
00:40:34,790 --> 00:40:37,970
de modo que les proporcione ciertas
funciones sin que tengan que activarlas

892
00:40:37,970 --> 00:40:40,110
ustedes mismos, todo el tiempo.

893
00:40:40,110 --> 00:40:43,520
Pero desafortunadamente,
aún cuando traté de compilar mi código,

894
00:40:43,520 --> 00:40:46,040
posiblemente no esté bien.

895
00:40:46,040 --> 00:40:50,120
Veo tres errores en un programa
que apenas tiene tres líneas de largo.

896
00:40:50,120 --> 00:40:51,509
No resulta muy prometedor.

897
00:40:51,509 --> 00:40:53,300
Bueno, no deben
sentirse abrumados

898
00:40:53,300 --> 00:40:55,280
cuando vean
muchos errores en la pantalla

899
00:40:55,280 --> 00:40:57,170
después de escribir un programa,
ya que algunas veces

900
00:40:57,170 --> 00:40:58,850
la computadora se confunde.

901
00:40:58,850 --> 00:41:02,660
Y el error más importante
probablemente sea el primero

902
00:41:02,660 --> 00:41:05,210
que detectó la computadora,
y que los otros sean simplemente

903
00:41:05,210 --> 00:41:08,269
dependientes de los
resultados de ese primer error.

904
00:41:08,269 --> 00:41:10,310
Así que no se sientan abrumados
por el número de errores.

905
00:41:10,310 --> 00:41:15,560
En vez de ello, miren
el primer error y notarán

906
00:41:15,560 --> 00:41:18,440
que la declaración implícita
de la función get_int es

907
00:41:18,440 --> 00:41:21,990
inválida en C99 y que
luego hay otras cosas misteriosas.

908
00:41:21,990 --> 00:41:26,030
Luego puedo ver una línea de mi código
como la tercera línea de esa salida.

909
00:41:26,030 --> 00:41:28,820
Por el momento
no sé lo que esto significa.

910
00:41:28,820 --> 00:41:31,880
Pero parece ser un error
relacionado de algún modo con get_int.

911
00:41:31,880 --> 00:41:32,840
Ahora, ¿por qué ocurre ésto?

912
00:41:32,840 --> 00:41:35,060
Bueno, resulta que
get_int no viene con C.

913
00:41:35,060 --> 00:41:36,590
Es una especie de rueda
de entrenamiento que utilizamos

914
00:41:36,590 --> 00:41:39,381
durante las primeras semanas
del curso, antes de eliminarlas,

915
00:41:39,381 --> 00:41:42,230
solo para que la
introducción a C sea más sencilla.

916
00:41:42,230 --> 00:41:44,570
En Scratch, solo tienen
un montón de piezas de rompecabezas

917
00:41:44,570 --> 00:41:45,861
las cuales facilitan las cosas.

918
00:41:45,861 --> 00:41:47,000
En C, no las tienen.

919
00:41:47,000 --> 00:41:49,014
Si simplemente quieren
obtener la entrada del usuario,

920
00:41:49,014 --> 00:41:50,930
tienen que saltar
a través de algunos aros,

921
00:41:50,930 --> 00:41:53,990
por así decirlo, y escribir más
líneas de código de lo que es ideal.

922
00:41:53,990 --> 00:41:58,880
Entonces, escribimos eso que llamamos
biblioteca, una colección de funciones,

923
00:41:58,880 --> 00:42:00,110
como un montón de Sams

924
00:42:00,110 --> 00:42:02,450
que saben hacer
cosas muy específicas.

925
00:42:02,450 --> 00:42:05,930
Y les pusimos nombres como
get_int, get_string y así sucesivamente.

926
00:42:05,930 --> 00:42:09,440
Pero el truco es que,
dado que CS50 los hizo,

927
00:42:09,440 --> 00:42:13,700
no se encuentran en la biblioteca
de entradas y salidas estándar.

928
00:42:13,700 --> 00:42:15,590
Están en la biblioteca de CS50.

929
00:42:15,590 --> 00:42:18,410
Así que si desean usar algunas de
estas funcionalidades durante la primera

930
00:42:18,410 --> 00:42:21,770
semana del curso, de hecho,
tengo que agregar una inclusión más.

931
00:42:21,770 --> 00:42:24,200
Debo decir,
hey computadora, no solo incluyas

932
00:42:24,200 --> 00:42:26,480
la biblioteca para las
entradas y salidas estándar,

933
00:42:26,480 --> 00:42:29,574
donde las bibliotecas son solo
una colección de códigos de alguien más,

934
00:42:29,574 --> 00:42:31,490
y en este caso,
las que solo contienen printf.

935
00:42:31,490 --> 00:42:36,440
Pero ahora la biblioteca de CS50
también contiene get_int y get_string,

936
00:42:36,440 --> 00:42:38,070
y otras piezas de funcionalidad.

937
00:42:38,070 --> 00:42:42,870
Entonces, guardaré el archivo y
volveré a la parte final de mi ventana.

938
00:42:42,870 --> 00:42:45,680
Y volveré a ejecutar make int,

939
00:42:45,680 --> 00:42:47,860
cruzaré mis dedos y Enter.

940
00:42:47,860 --> 00:42:48,860
Diablos.

941
00:42:48,860 --> 00:42:51,050
¿Qué sucedió aquí?

942
00:42:51,050 --> 00:42:53,300
Este es mi segundo error,
pero vamos progresando.

943
00:42:53,300 --> 00:42:55,700
Ahora tengo dos errores en rojo.

944
00:42:55,700 --> 00:42:58,940
Y esta vez dice, error,
más conversiones por ciento

945
00:42:58,940 --> 00:43:01,760
que argumentos de datos.

946
00:43:01,760 --> 00:43:03,749
Puedo concentrar mi mente en eso.

947
00:43:03,749 --> 00:43:06,290
Pero noten que no he practicado
lo que les aconsejé hace un momento.

948
00:43:06,290 --> 00:43:09,532
¿Qué falta en la línea 7 que resalté?

949
00:43:09,532 --> 00:43:11,615
PÚBLICO: Debes poner una
coma después de la cadena

950
00:43:11,615 --> 00:43:13,805
y después añadir la variable.

951
00:43:13,805 --> 00:43:14,930
DAVID: Sí, exactamente.

952
00:43:14,930 --> 00:43:18,400
Tengo este marcador %i
y dice que debo introducir un entero aquí.

953
00:43:18,400 --> 00:43:19,780
Pero no terminé la idea.

954
00:43:19,780 --> 00:43:23,230
Como algunas piezas en Scratch,
que tienen varias cajas blancas,

955
00:43:23,230 --> 00:43:25,540
en las que se puede escribir o arrastrar
otras piezas del rompecabezas.

956
00:43:25,540 --> 00:43:28,060
Así que aún no he terminado la idea.

957
00:43:28,060 --> 00:43:32,500
Debo indicar el valor que
deseo introducir en esta cadena,

958
00:43:32,500 --> 00:43:36,160
y en C pueden hacerlo
si separan las entradas con comas.

959
00:43:36,160 --> 00:43:40,930
Y, de hecho, esas entradas a las funciones
se llaman parámetros o argumentos,

960
00:43:40,930 --> 00:43:42,290
según el contexto.

961
00:43:42,290 --> 00:43:44,980
Y entonces, ¿a cuál
argumento deseo llegar?

962
00:43:44,980 --> 00:43:49,180
Bueno, quiero mover i como una segunda
caja blanca en una pieza de Scratch

963
00:43:49,180 --> 00:43:53,950
que influya de algún modo en la primera
entrada, conocida también como argumento.

964
00:43:53,950 --> 00:43:59,360
Y ahora, si en serio cruzo mis dedos,
guardo el archivo y ejecuto make int,

965
00:43:59,360 --> 00:44:02,650
ya no tengo más errores

966
00:44:02,650 --> 00:44:03,920
y no tener errores es bueno.

967
00:44:03,920 --> 00:44:09,900
Ahora, si escribo ls, ¿cuál archivo
debería ver entre mis otros archivos?

968
00:44:09,900 --> 00:44:11,835
Con suerte será
un programa llamado int.

969
00:44:11,835 --> 00:44:14,590
De hecho se encuentra allí en verde, con
un asterisco después de su significado,

970
00:44:14,590 --> 00:44:18,280
Puedo poner ./int, integer.

971
00:44:18,280 --> 00:44:20,050
Dénme un número.

972
00:44:20,050 --> 00:44:21,600
Lo primero que oí fue 3.

973
00:44:21,600 --> 00:44:22,570
Hello, 3.

974
00:44:22,570 --> 00:44:25,030
Vamos a ejecutarlo otra vez.

975
00:44:25,030 --> 00:44:26,860
Escuché 6 antes.

976
00:44:26,860 --> 00:44:27,490
Hello, 6.

977
00:44:27,490 --> 00:44:34,270
Y podemos hacer esto todo el día, a menos
que probemos al azar y escribamos monkey.

978
00:44:34,270 --> 00:44:36,130
Pero el programa va a notarlo.

979
00:44:36,130 --> 00:44:39,460
Eso es parte de la funcionalidad que
obtendrán con la biblioteca de códigos.

980
00:44:39,460 --> 00:44:42,850
Nos tomamos el tiempo
para implementar get_int de tal manera

981
00:44:42,850 --> 00:44:44,920
que si ustedes, humanos,
no nos proporcionan un int,

982
00:44:44,920 --> 00:44:47,570
solamente los reescribiremos,
los reescribiremos y los reescribiremos.

983
00:44:47,570 --> 00:44:49,660
Entonces, en este caso,
no sirve escribir una palabra,

984
00:44:49,660 --> 00:44:53,680
tampoco funciona escribir algo
como 1.23, porque no es un entero.

985
00:44:53,680 --> 00:44:55,870
Eso es lo que
llamamos un número real,

986
00:44:55,870 --> 00:44:59,050
un número con punto flotante,
donde realmente hay un punto en él.

987
00:44:59,050 --> 00:45:04,250
Pero si escribo algo como
42, entonces obtendré un hello 42.

988
00:45:04,250 --> 00:45:06,660
Haré aquí una pausa,
porque hemos visto demasiado

989
00:45:06,660 --> 00:45:11,320
y he dejado muy poco
tiempo para hacer preguntas.

990
00:45:11,320 --> 00:45:12,542
¿Sí?

991
00:45:12,542 --> 00:45:15,458
PÚBLICO: Entiendo que
hizo una biblioteca para que la usemos,

992
00:45:15,458 --> 00:45:19,034
pero cuando etiqueta [INAUDIBLE]
biblioteca, ¿de dónde se obtiene?

993
00:45:19,034 --> 00:45:20,450
DAVID: Es una excelente pregunta.

994
00:45:20,450 --> 00:45:24,040
Cuando se pone esa línea
de código al principio del programa,

995
00:45:24,040 --> 00:45:25,120
¿dónde está el código?

996
00:45:25,120 --> 00:45:28,750
Fue instalado previamente
en algún lugar en la nube,

997
00:45:28,750 --> 00:45:33,100
dentro de alguna
carpeta en el IDE de su CS50.

998
00:45:33,100 --> 00:45:36,700
Y gracias a que instalamos
software estándar, ese software,

999
00:45:36,700 --> 00:45:41,500
como Clang, solo sabe
en dónde buscar en el disco duro

1000
00:45:41,500 --> 00:45:42,550
al que tiene acceso.

1001
00:45:42,550 --> 00:45:47,800
Tenemos un archivo que escribimos
antes, llamado CS50.c, el cual tiene

1002
00:45:47,800 --> 00:45:49,760
todo el código C que lo implementa.

1003
00:45:49,760 --> 00:45:52,800
En CS50.h solo hay un resumen.

1004
00:45:52,800 --> 00:45:55,100
Pronto veremos .h, en el
encabezado de un archivo.

1005
00:45:55,100 --> 00:45:57,700
Y en realidad solo
tiene un resumen breve

1006
00:45:57,700 --> 00:45:59,710
de la funcionalidad
a la que tienen acceso,

1007
00:45:59,710 --> 00:46:01,649
así que simplemente
tienen que escribir una línea

1008
00:46:01,649 --> 00:46:04,440
y después tendrán acceso a toda la caja
de herramientas de la funcionalidad

1009
00:46:04,440 --> 00:46:09,610
en la biblioteca de CS50, la biblioteca
estándar de I/O o en otro lugar.

1010
00:46:09,610 --> 00:46:11,020
Eso es lo que obtienen.

1011
00:46:11,020 --> 00:46:12,244
¿Sí?

1012
00:46:12,244 --> 00:46:19,855
PÚBLICO: [INAUDIBLE] y
entonces como [INAUDIBLE].

1013
00:46:19,855 --> 00:46:20,730
DAVID: Exacto.

1014
00:46:20,730 --> 00:46:23,520
Pueden usar cualquiera de esas
funciones, get_int, get_float, get_string,

1015
00:46:23,520 --> 00:46:25,853
y aún no hemos hablado
de lo que son algunas de ellas,

1016
00:46:25,853 --> 00:46:28,440
pero siempre y cuando las almacenen
en el tipo de variable correcta,

1017
00:46:28,440 --> 00:46:31,710
las cambien a la cadena, o cambien
la cadena en algo más, entonces sí,

1018
00:46:31,710 --> 00:46:34,260
pueden utilizar cualquiera
para obtener la entrada del usuario,

1019
00:46:34,260 --> 00:46:36,300
así sus programas serán
realmente dinámicos.

1020
00:46:36,300 --> 00:46:38,591
No implicará dar
clics con el ratón y demás,

1021
00:46:38,591 --> 00:46:41,610
pero al menos pueden tomar
la entrada textual del usuario.

1022
00:46:41,610 --> 00:46:46,210
Ahora abriré un
programa que escribí anteriormente.

1023
00:46:46,210 --> 00:46:47,880
Para continuar tomaré esto

1024
00:46:47,880 --> 00:46:50,360
que se llama ints, en plural.

1025
00:46:50,360 --> 00:46:52,690
Y después abriré esto
de la siguiente manera.

1026
00:46:52,690 --> 00:46:54,981
Este es el código que también se
encuentra en el sitio de web del curso,

1027
00:46:54,981 --> 00:46:56,970
así que pueden echarle un
vistazo en cualquier momento.

1028
00:46:56,970 --> 00:46:59,010
Es un poco más complicado

1029
00:46:59,010 --> 00:47:00,390
pero se ve como sigue.

1030
00:47:00,390 --> 00:47:03,210
Hasta arriba del archivo, noten
que comienza con diagonal diagonal.

1031
00:47:03,210 --> 00:47:05,370
Resulta que los
lenguajes de programación como C

1032
00:47:05,370 --> 00:47:06,780
son compatibles con
lo que llamamos comentarios.

1033
00:47:06,780 --> 00:47:10,260
Los comentarios no son un código,
son notas para uno mismo

1034
00:47:10,260 --> 00:47:12,480
que recuerdan aquello
con lo que se estaba trabajando,

1035
00:47:12,480 --> 00:47:15,130
o a sus compañeros lo que
se supone que hace el programa.

1036
00:47:15,130 --> 00:47:18,870
Y en este caso quiero mostrar
la aritmética de enteros, lo que sea que

1037
00:47:18,870 --> 00:47:19,620
esto signifique.

1038
00:47:19,620 --> 00:47:21,977
Ahora tengo un par
de "include" y los agrupé.

1039
00:47:21,977 --> 00:47:24,060
Añadí líneas en blanco,
pero eso es solamente

1040
00:47:24,060 --> 00:47:25,620
para mantener
todo limpio y ordenado.

1041
00:47:25,620 --> 00:47:27,090
No es estrictamente necesario.

1042
00:47:27,090 --> 00:47:29,940
Aquí tengo main
y probablemente volveremos

1043
00:47:29,940 --> 00:47:32,630
para discutir
por qué tenemos ints y void.

1044
00:47:32,630 --> 00:47:35,130
Pero hoy, supongamos
que esto es el equivalente

1045
00:47:35,130 --> 00:47:37,020
a cuando hice clic
en la bandera verde.

1046
00:47:37,020 --> 00:47:39,300
Y ahora tenemos aquí
algunas líneas de código.

1047
00:47:39,300 --> 00:47:41,460
Tengo dos
comentarios que les dirán

1048
00:47:41,460 --> 00:47:45,380
lo que ocurre en el
cursor del usuario para x y para y.

1049
00:47:45,380 --> 00:47:50,020
Debajo de cada comentario
están las líneas de código que hacen eso.

1050
00:47:50,020 --> 00:47:52,080
¿Y qué opinan sobre
esta línea de código?

1051
00:47:52,080 --> 00:47:55,800
Es similar a lo que vimos
apenas, aunque con otros nombres.

1052
00:47:55,800 --> 00:47:57,934
En el lado izquierdo de la línea 9

1053
00:47:57,934 --> 00:47:59,850
estamos diciendo,
hey computadora, dame una variable

1054
00:47:59,850 --> 00:48:03,830
que se llame x, y almacenarás
en ella cierto tipo de datos,

1055
00:48:03,830 --> 00:48:06,210
int, un entero, como un número.

1056
00:48:06,210 --> 00:48:09,960
Luego, a la derecha, se llamará

1057
00:48:09,960 --> 00:48:13,800
get_int, que es como
otra versión de la que Sam recopiló,

1058
00:48:13,800 --> 00:48:16,740
y obtendrá un entero del usuario,
en donde el usuario lo escriba

1059
00:48:16,740 --> 00:48:20,610
en el teclado, presione Enter y luego
get_int lo devuelva al programa.

1060
00:48:20,610 --> 00:48:25,260
Y ya que get_int está
en el lado derecho del signo igual,

1061
00:48:25,260 --> 00:48:27,660
ese valor, como el que Sam
me entregó en un pedazo de papel,

1062
00:48:27,660 --> 00:48:29,730
se transferirá
de derecha a izquierda

1063
00:48:29,730 --> 00:48:33,370
y se almacenará
a la izquierda de la variable.

1064
00:48:33,370 --> 00:48:37,410
Así que si escribo el número 1,
x contendrá el número uno.

1065
00:48:37,410 --> 00:48:41,040
Y si el siguiente
número que escribo es el 2,

1066
00:48:41,040 --> 00:48:45,780
la variable y almacenará
el número 2 de derecha a izquierda.

1067
00:48:45,780 --> 00:48:48,300
Ahora, esto es un poco
abrumador a primera vista,

1068
00:48:48,300 --> 00:48:51,270
pero es solo un copia y pega de
algunas de las mismas ideas

1069
00:48:51,270 --> 00:48:52,390
para hacer aritmética.

1070
00:48:52,390 --> 00:48:54,270
En este programa quería demostrar

1071
00:48:54,270 --> 00:48:56,550
algunas operaciones aritméticas
que son compatibles con C.

1072
00:48:56,550 --> 00:48:59,399
Pueden sumar, restar,
multiplicar y dividir números.

1073
00:48:59,399 --> 00:49:02,190
Puede no ser obvio cual símbolo
deben utilizar y por eso veremos esto.

1074
00:49:02,190 --> 00:49:05,760
En la línea 15, vemos
el siguiente ejemplo.

1075
00:49:05,760 --> 00:49:09,020
Tenemos aquí la cadena
que dice, introduce algún valor,

1076
00:49:09,020 --> 00:49:12,270
luego dice la palabra "plus",
entonces añade un valor,

1077
00:49:12,270 --> 00:49:14,450
luego dice la palabra "is",
entonces añade un tercer valor.

1078
00:49:14,450 --> 00:49:16,440
Todos los valores son enteros

1079
00:49:16,440 --> 00:49:20,180
porque después de esta cadena
resaltada, tengo tres entradas adicionales

1080
00:49:20,180 --> 00:49:20,940
para la función printf.

1081
00:49:20,940 --> 00:49:24,120
Tres valores adicionales
para añadir, literalmente, a x y a y.

1082
00:49:23,820 --> 00:49:29,420
Y si quieren hacer matemáticas
en C, solo escriban x más y,

1083
00:49:29,420 --> 00:49:32,960
eso devolverá 1 más 2, o cualquiera
de los valores que contenga.

1084
00:49:32,460 --> 00:49:35,700
Y de nuevo, aquí habrá tres
valores separados por comas

1085
00:49:35,700 --> 00:49:40,860
porque hay tres marcadores
de posición en el lado izquierdo.

1086
00:49:40,860 --> 00:49:43,800
Mientras tanto, el resto
es solo copiar y pegar

1087
00:49:43,800 --> 00:49:45,660
pero con diferentes
palabras y operadores.

1088
00:49:45,660 --> 00:49:48,520
Entonces,
algo menos algo es algo.

1089
00:49:48,520 --> 00:49:52,350
¿Y cómo obtengo esa salida,
x y y, y después x menos y?

1090
00:49:52,350 --> 00:49:55,060
Entonces menos es
lo que se espera que sea.

1091
00:49:55,060 --> 00:49:57,210
x algunas veces algo, es algo.

1092
00:49:57,210 --> 00:50:00,810
Bueno, esto sería x, y, x * y.

1093
00:50:00,810 --> 00:50:04,350
Entonces, el asterisco en C
representa la multiplicación.

1094
00:50:04,350 --> 00:50:06,900
Y entonces x algo,
dividido por algo, es algo,

1095
00:50:06,900 --> 00:50:11,490
x, y, x / y
nos da la división.

1096
00:50:11,490 --> 00:50:13,980
Y después, la última,
tal vez sea la única extraña

1097
00:50:13,980 --> 00:50:16,020
o la que nunca
escribieron con un teclado.

1098
00:50:16,020 --> 00:50:20,940
El restante de algo cuando
es dividido por algo, es algo

1099
00:50:20,940 --> 00:50:23,214
y ese carácter
es el signo de porcentaje.

1100
00:50:23,214 --> 00:50:25,380
Probablemente nunca
lo escribieron como un comando,

1101
00:50:25,380 --> 00:50:27,210
a menos que hayan practicado
la aritmética modular, pero tal vez

1102
00:50:27,210 --> 00:50:28,668
recordaron la escuela primaria.

1103
00:50:28,668 --> 00:50:30,820
Si divido un número por otro,
¿cuál es el restante?

1104
00:50:30,820 --> 00:50:34,080
Este signo de porcentaje
sirve para expresar esa misma idea.

1105
00:50:34,080 --> 00:50:36,340
Ahora voy
a compilar este programa.

1106
00:50:36,340 --> 00:50:39,000
Y en resumen, ¿cuál
es la forma más breve para

1107
00:50:39,000 --> 00:50:44,490
compilar un programa que
está en un archivo llamado int.c?

1108
00:50:44,490 --> 00:50:45,564
Make ints.

1109
00:50:45,564 --> 00:50:47,730
Una vez más nos abstraemos
de todos esos detalles

1110
00:50:47,730 --> 00:50:48,740
y será un patrón.

1111
00:50:48,740 --> 00:50:51,720
Solo cuando las cosas parezcan
demasiado detalladas y difíciles,

1112
00:50:51,720 --> 00:50:54,270
colocaremos una capa superior,
como un modo fácil de hacer las cosas,

1113
00:50:54,270 --> 00:50:56,790
y daremos por hecho
que sabemos que algo

1114
00:50:56,790 --> 00:50:58,350
está sucediendo
por debajo del agua.

1115
00:50:58,350 --> 00:51:01,350
Parece que make ints funciona
porque no hay mensajes de error.

1116
00:51:01,350 --> 00:51:03,780
Entonces ./int Enter.

1117
00:51:03,780 --> 00:51:04,940
x será 1.

1118
00:51:04,940 --> 00:51:07,572

1119
00:51:07,572 --> 00:51:08,530
De hecho, hagamos esto.

1120
00:51:08,530 --> 00:51:10,110
Probemos con 2.

1121
00:51:10,110 --> 00:51:12,420
2 y 2, Enter.

1122
00:51:12,420 --> 00:51:13,673
Muy bien, 2 más 2 es 4,

1123
00:51:13,673 --> 00:51:15,040
2 menos 2 es 0,

1124
00:51:15,040 --> 00:51:17,180
2 por 2 es 4,

1125
00:51:17,180 --> 00:51:18,590
2 dividido por 2 es 1,

1126
00:51:18,590 --> 00:51:21,630
el restante de 2
dividido por 2 es 0.

1127
00:51:21,630 --> 00:51:24,680
Creo que ya son
todos los que hay por revisar.

1128
00:51:24,680 --> 00:51:27,190
Pero... pero, pero, pero...

1129
00:51:27,190 --> 00:51:31,082
Siento que la prueba
no es realmente una prueba.

1130
00:51:31,082 --> 00:51:32,540
Así que trataremos una vez más.

1131
00:51:32,540 --> 00:51:33,400
1 por x,

1132
00:51:33,400 --> 00:51:35,270
2 por y,

1133
00:51:35,270 --> 00:51:36,890
OK, 1 más 2 es 3,

1134
00:51:36,890 --> 00:51:38,780
1 menos 2 es 1 negativo,

1135
00:51:38,780 --> 00:51:39,980
2 por 1 es 2,

1136
00:51:39,980 --> 00:51:45,140
1 dividido por 2... ¿es 0?

1137
00:51:45,140 --> 00:51:47,390
¿Qué debería ser?

1138
00:51:47,390 --> 00:51:49,000
Probablemente 0.5, ¿cierto?

1139
00:51:49,000 --> 00:51:49,730
Algo como 1/2.

1140
00:51:49,730 --> 00:51:52,520
1 dividido por 2
no es matemáticamente cero,

1141
00:51:52,520 --> 00:51:54,990
pero el restante
de dividir 1 por 2 es 1,

1142
00:51:54,990 --> 00:51:57,800
así que por alguna
razón, la división está rota.

1143
00:51:57,800 --> 00:52:01,040
Al parecer mi computadora
no divide correctamente.

1144
00:52:01,040 --> 00:52:02,150
Pero, ¿por qué ocurre esto?

1145
00:52:02,150 --> 00:52:05,570
Bueno, probablemente
puedan adivinar aunque no sea obvio.

1146
00:52:05,570 --> 00:52:07,580
¿a qué se debe esto?

1147
00:52:07,580 --> 00:52:08,380
¿Qué está pasando?

1148
00:52:08,380 --> 00:52:09,040
¿Sí?

1149
00:52:09,040 --> 00:52:10,290
PÚBLICO: Está buscando un entero.

1150
00:52:10,290 --> 00:52:11,790
DAVID: Busca un entero.

1151
00:52:11,790 --> 00:52:13,250
Entonces dividió 1 por 2

1152
00:52:13,250 --> 00:52:16,730
y si la salida debe ser
un entero, porque de %s

1153
00:52:16,730 --> 00:52:19,140
tiene que elegir
una u otra manera.

1154
00:52:19,140 --> 00:52:22,057
Entonces, lo que hace un
programa de computadora es arrojar

1155
00:52:22,057 --> 00:52:23,390
todo en el punto decimal.

1156
00:52:23,390 --> 00:52:27,530
Si utilizan ints y los ints
no tienen puntos decimales,

1157
00:52:27,530 --> 00:52:30,020
serían números reales
en vez de números irracionales,

1158
00:52:30,020 --> 00:52:33,310
solo arrojaremos todo
después del punto decimal

1159
00:52:33,310 --> 00:52:35,060
y estaremos a la izquierda,
por supuesto, del cero.

1160
00:52:35,060 --> 00:52:38,660
Porque 1 dividido por 2
técnicamente es 0.5.

1161
00:52:38,660 --> 00:52:41,300
Así que perdemos
todo después del punto.

1162
00:52:41,300 --> 00:52:42,570
¿Cómo lo arreglamos?

1163
00:52:42,570 --> 00:52:46,060
Bueno, podemos
solucionarlo de un par de maneras,

1164
00:52:46,060 --> 00:52:48,870
pero quizás lo más
simple es lo siguiente.

1165
00:52:48,870 --> 00:52:52,340
Dejen prosigo y tomo otro
ejemplo que escribí anteriormente.

1166
00:52:52,340 --> 00:52:57,350
Este se llama float.c, y
float es una referencia

1167
00:52:57,350 --> 00:52:59,450
a un punto flotante en aritmética.

1168
00:52:59,450 --> 00:53:01,670
Literalmente, el punto flotante
se refiere a un punto

1169
00:53:01,670 --> 00:53:05,390
que se mueve de izquierda a derecha,
según el valor trate de expresar.

1170
00:53:05,390 --> 00:53:10,310
Y en este caso, noten que cambié
el programa para que ya no utilice

1171
00:53:10,310 --> 00:53:13,010
más ints sino floats.

1172
00:53:13,010 --> 00:53:14,060
Entonces es
un tercer tipo de datos.

1173
00:53:14,060 --> 00:53:15,110
Teníamos cadena.

1174
00:53:15,110 --> 00:53:15,770
Teníamos int.

1175
00:53:15,770 --> 00:53:16,520
Y tenemos float.

1176
00:53:16,520 --> 00:53:19,710
Y float permite que nuestros
números tengan puntos en ellos.

1177
00:53:19,710 --> 00:53:24,460
Y ahora, si hago algo
de aritmética aquí, solo una línea,

1178
00:53:24,460 --> 00:53:26,480
será la misma
línea de código anterior,

1179
00:53:26,480 --> 00:53:29,600
pero ahora utilizo %f en vez de %i

1180
00:53:29,600 --> 00:53:31,260
para imprimir
un valor de punto flotante.

1181
00:53:31,260 --> 00:53:33,310
Vamos a volverlos float.

1182
00:53:33,310 --> 00:53:34,380
Enter.

1183
00:53:34,380 --> 00:53:35,840
./floats.

1184
00:53:35,840 --> 00:53:36,810
Y lo intentamos de nuevo.

1185
00:53:36,810 --> 00:53:39,330
1, 2.

1186
00:53:39,330 --> 00:53:42,800
Y ahora obtengo
la respuesta que espero.

1187
00:53:42,800 --> 00:53:44,160
Eso es algo interesante.

1188
00:53:44,160 --> 00:53:48,930
Ahora solo tengo que ser
más preciso con lo que está pasando.

1189
00:53:48,930 --> 00:53:52,670
Así que tenemos
cadenas, ints y floats.

1190
00:53:52,670 --> 00:53:55,580
Haré una pausa para resolver
dudas sobre lo que generalmente

1191
00:53:55,580 --> 00:53:59,560
llamamos tipos,
tipos de variables.

1192
00:53:59,560 --> 00:54:00,196
¿Sí?

1193
00:54:00,196 --> 00:54:01,900
PÚBLICO: ¿Cómo se aumenta
el número de cifras en los decimales?

1194
00:54:01,900 --> 00:54:02,910
DAVID: Oh, muy buena pregunta.

1195
00:54:02,910 --> 00:54:04,951
Cómo aumentar el número
de cifras en los decimales.

1196
00:54:04,951 --> 00:54:07,590
Podemos hacerlo de
una manera muy específica.

1197
00:54:07,590 --> 00:54:10,940
Justo ahora, tenemos uno, dos,
tres, cuatro, cinco, seis valores

1198
00:54:10,940 --> 00:54:13,970
impresos de manera estándar.
Supongamos que queremos tener 10.

1199
00:54:13,970 --> 00:54:16,100
Es un poco críptico,
pero en general puedo

1200
00:54:16,100 --> 00:54:20,600
poner .10, que es la
manera oficial de decir dame

1201
00:54:20,600 --> 00:54:22,200
10 números
después del punto decimal.

1202
00:54:22,200 --> 00:54:24,320
Y francamente olvido este tipo
de detalles todo el tiempo.

1203
00:54:24,320 --> 00:54:27,195
Solo Google y ustedes
pueden obtener ese tipo de información.

1204
00:54:27,195 --> 00:54:28,940
Vamos a intentar con make floats

1205
00:54:28,940 --> 00:54:30,820
y ahora ./floats.

1206
00:54:30,820 --> 00:54:32,120
1, 2.

1207
00:54:32,120 --> 00:54:35,030
Y así obtengo más ceros
después del punto decimal.

1208
00:54:35,030 --> 00:54:38,810
También pueden ir en otra dirección
para hacer redondeos implícitamente.

1209
00:54:38,810 --> 00:54:39,967
Sí, pregunta.

1210
00:54:39,967 --> 00:54:43,209
PÚBLICO: ¿Pueden tener los
primeros dos enteros [INAUDIBLE]?

1211
00:54:43,209 --> 00:54:44,500
DAVID: Ah, buena pregunta.

1212
00:54:44,500 --> 00:54:48,030
¿Pueden los dos primeros ser enteros
y los dos últimos ser un float?

1213
00:54:48,030 --> 00:54:52,690
Puedo escribir
int x, get int.

1214
00:54:52,690 --> 00:54:56,010
int y, get int.

1215
00:54:56,010 --> 00:55:00,722
Y cambiar esto para i, i,
pero dejándolo como un float.

1216
00:55:00,722 --> 00:55:01,680
Es muy buena pregunta.

1217
00:55:01,680 --> 00:55:03,472
Pero nada es trivial,
en cualquier momento

1218
00:55:03,472 --> 00:55:05,888
pueden surgir este tipo de
preguntas cuando van por su cuenta

1219
00:55:05,888 --> 00:55:08,530
y no solo en un entorno
como este, así que inténtenlo.

1220
00:55:08,530 --> 00:55:10,900
Entonces pongamos
de nuevo make floats,

1221
00:55:10,900 --> 00:55:14,700
y no es bueno,
pero el compilador notó

1222
00:55:14,700 --> 00:55:17,370
que hice algo
que no está permitido.

1223
00:55:17,370 --> 00:55:20,120
El compilador siempre es misterioso,
estos son mensajes de error.

1224
00:55:20,120 --> 00:55:21,990
Pero el formato
especifica un tipo double.

1225
00:55:21,990 --> 00:55:24,360
Double es un
valor de punto flotante

1226
00:55:24,360 --> 00:55:27,540
pero con más capacidad para
los números después del punto decimal.

1227
00:55:27,540 --> 00:55:31,560
En pocas palabras, float
generalmente utiliza 32 bits,

1228
00:55:31,560 --> 00:55:34,050
lo cual nos da muchos
ceros y unos con los cuales

1229
00:55:34,050 --> 00:55:37,170
se representan valores
de punto flotante o números reales.

1230
00:55:37,170 --> 00:55:40,000
Si se utiliza un double,
se obtienen 64 bits

1231
00:55:40,000 --> 00:55:42,000
y según nuestra conversación
en la primera lección,

1232
00:55:42,000 --> 00:55:45,490
solo significa que tienen un mayor
rango de valores, o mayor precisión.

1233
00:55:45,490 --> 00:55:48,900
Así especificamos un tipo double
pero el argumento es de tipo int.

1234
00:55:48,900 --> 00:55:51,307
Así que el compilador nos cachó
y simplemente no podemos hacerlo.

1235
00:55:51,307 --> 00:55:53,640
Podríamos omitir esta
advertencia y tratar de hacerlo,

1236
00:55:53,640 --> 00:55:56,010
pero es posible que obtengamos
un comportamiento inesperado.

1237
00:55:56,010 --> 00:55:56,670
Buena pregunta.

1238
00:55:56,670 --> 00:55:59,290
¿Había otra
pregunta antes de esta?

1239
00:55:59,290 --> 00:55:59,790
¿No?

1240
00:55:59,790 --> 00:56:00,600
OK.

1241
00:56:00,600 --> 00:56:03,490
Muy bien, esto es
un tipo de valor diferente.

1242
00:56:03,490 --> 00:56:07,850
Pero introduzcamos algunas de esas
construcciones lógicas que prometimos

1243
00:56:07,850 --> 00:56:08,850
al inicio.

1244
00:56:08,850 --> 00:56:10,380
Prosigamos.

1245
00:56:10,380 --> 00:56:12,750
A continuación
tomaré un archivo,

1246
00:56:12,750 --> 00:56:15,390
que también está
en el sitio web del curso,

1247
00:56:15,390 --> 00:56:18,480
llamado conditions.c.

1248
00:56:18,480 --> 00:56:22,810
Es un programa que también escribí
y que trata un poco de lógica.

1249
00:56:22,810 --> 00:56:24,480
De nuevo estoy siguiendo un patrón

1250
00:56:24,480 --> 00:56:28,080
para que en cada tipo de programa
se presenten una o dos ideas nuevas.

1251
00:56:28,080 --> 00:56:32,880
Entonces tengo get_int dos veces
y almacenan los valores en x y y,

1252
00:56:32,880 --> 00:56:35,650
y luego llevaré a cabo
algunas operaciones lógicas.

1253
00:56:35,650 --> 00:56:39,000
En realidad se trata de copiar
y pegar lo que hemos visto antes,

1254
00:56:39,000 --> 00:56:41,787
pero es, en código, el modo
en que podría comparar dos variables.

1255
00:56:41,787 --> 00:56:44,370
Dije antes que no tenía idea
de dónde provienen x y y, ¿verdad?

1256
00:56:44,370 --> 00:56:46,320
Vimos el ejemplo fuera de contexto

1257
00:56:46,320 --> 00:56:47,310
y ahora tenemos el contexto.

1258
00:56:47,310 --> 00:56:50,220
Las líneas que vemos arriba
las llamamos dos veces get_int

1259
00:56:50,220 --> 00:56:52,240
y almacenan los valores
en x y y, respectivamente.

1260
00:56:52,240 --> 00:56:56,140
Así que ahora x y y existen
realmente en mi programa.

1261
00:56:56,140 --> 00:56:58,740
Entonces, aquí abajo, solo
hago exactamente lo mismo

1262
00:56:58,740 --> 00:57:01,380
que hacía aquella gran colección
de piezas de rompecabezas en Scratch,

1263
00:57:01,380 --> 00:57:07,920
si compilo y ejecuto
este programa, conditions.c,

1264
00:57:07,920 --> 00:57:08,920
veamos que pasa.

1265
00:57:08,920 --> 00:57:13,480
ponemos las condiciones y
ahora escribimos ./conditions.

1266
00:57:13,480 --> 00:57:20,350
1 y luego 2,
¿qué debe imprimir?

1267
00:57:20,350 --> 00:57:21,639
Con suerte,
que x es menor que y.

1268
00:57:21,639 --> 00:57:23,680
Y de hecho, eso es
exactamente lo que hace el programa.

1269
00:57:23,680 --> 00:57:27,100
Si lo ejecuto otra vez con 2 y 1,
x es mayor que y.

1270
00:57:27,100 --> 00:57:30,197
Y si lo ejecuto con 1 y 1,
x es igual a y.

1271
00:57:30,197 --> 00:57:32,530
Solo estoy traduciendo las
piezas del rompecabezas de Scratch,

1272
00:57:32,530 --> 00:57:35,680
en este caso para ver
que me da algo un poco diferente.

1273
00:57:35,680 --> 00:57:37,990
Pero, ¿qué pasa si no quiero
comparar solo una cosa?

1274
00:57:37,990 --> 00:57:41,672
En Scratch, es probable que
rápidamente construyan escenarios

1275
00:57:41,672 --> 00:57:43,630
donde desearán
comprobar varias cosas a la vez,

1276
00:57:43,630 --> 00:57:45,588
o tal vez quieran hacer
varias preguntas.

1277
00:57:45,588 --> 00:57:48,660
Si no, es probable que
crucen ese puente en poco tiempo.

1278
00:57:48,660 --> 00:57:50,410
Ahora, para continuar
pondré otro ejemplo.

1279
00:57:50,410 --> 00:57:51,820
Empezaré desde cero.

1280
00:57:51,820 --> 00:57:54,610
Voy a llamar a este
noswitch.c, por razones

1281
00:57:54,610 --> 00:57:56,260
que se aclararán en un momento,

1282
00:57:56,260 --> 00:57:59,930
y lo incluiré
en la biblioteca CS50.

1283
00:57:59,930 --> 00:58:02,530
Lo incluiré en la biblioteca
estándar, de modo que

1284
00:58:02,530 --> 00:58:05,420
pueda obtener la entrada
y la salida de impresión.

1285
00:58:05,420 --> 00:58:08,980
int main(void), la cual es una
línea que por hoy daremos por hecho.

1286
00:58:08,980 --> 00:58:13,540
Y luego pondré lo siguiente,
char c = get_char("Answer: ");

1287
00:58:13,540 --> 00:58:16,750
Y solo quiero que esto
sea la respuesta del usuario.

1288
00:58:16,750 --> 00:58:19,120
char es un simple
carácter, no es una cadena que

1289
00:58:19,120 --> 00:58:20,975
pueda ser toda
una frase o un párrafo.

1290
00:58:20,975 --> 00:58:22,600
Y luego escribiré lo siguiente.

1291
00:58:22,600 --> 00:58:27,850
If c == 'Y', entonces

1292
00:58:27,850 --> 00:58:31,880
escribo printf("yes\ n");

1293
00:58:31,880 --> 00:58:36,430
else if (c == 'N')

1294
00:58:36,430 --> 00:58:41,560
esto imprimirá printf("no\ n);

1295
00:58:41,560 --> 00:58:42,610
Y eso es todo.

1296
00:58:42,610 --> 00:58:43,870
Entonces,
¿qué hace este programa?

1297
00:58:43,870 --> 00:58:47,079
Bueno, si nunca ejecutaron un programa
con un botón para dar clic en sí o no,

1298
00:58:47,079 --> 00:58:49,870
o tal vez un programa de línea
de comandos, o utilicen el teclado

1299
00:58:49,870 --> 00:58:52,453
y tengan que escribir sí, estoy de
acuerdo con los términos y condiciones

1300
00:58:52,453 --> 00:58:56,240
o no, no lo estoy, esta es una
forma súper sencilla para comprobar

1301
00:58:56,240 --> 00:59:00,010
si el humano escribió
y para yes o n para no.

1302
00:59:00,010 --> 00:59:03,890
Entonces ejecutemos esto y volvamos
a la razón por la cual se implementó así.

1303
00:59:03,890 --> 00:59:05,600
Pongamos make noswitch

1304
00:59:05,600 --> 00:59:08,620
y luego regresaré
al porqué de este nombre.

1305
00:59:08,620 --> 00:59:13,780
Ahora pondré y
ejecutaré ./noswitch

1306
00:59:13,780 --> 00:59:14,480
Enter.

1307
00:59:14,480 --> 00:59:16,360
Y mi respuesta
debería ser y para yes.

1308
00:59:16,360 --> 00:59:20,550

1309
00:59:20,550 --> 00:59:22,600
Tiene errores.

1310
00:59:22,600 --> 00:59:23,100
Qué...

1311
00:59:23,100 --> 00:59:25,890
¿Qué estaba esperando?

1312
00:59:25,890 --> 00:59:29,910
Sí, esperaba que al
presionar y, imprimiera yes.

1313
00:59:29,910 --> 00:59:33,000
Pero pensemos en lo
que mi código está pidiendo.

1314
00:59:33,000 --> 00:59:34,170
¿Dónde está el error?

1315
00:59:34,170 --> 00:59:36,900
¿Por qué mi programa no imprime Y-E-S?

1316
00:59:36,900 --> 00:59:37,530
¿Sí?

1317
00:59:37,530 --> 00:59:38,310
PÚBLICO: No está en mayúsculas.

1318
00:59:38,310 --> 00:59:39,290
DAVID: sí, es tan
sencillo como eso.

1319
00:59:39,290 --> 00:59:40,165
No está en mayúsculas.

1320
00:59:40,165 --> 00:59:42,460
Así que recuerden,
la precisión es super importante.

1321
00:59:42,460 --> 00:59:46,140
Escribí un programa que dice
if c, si el carácter que el usuario

1322
00:59:46,140 --> 00:59:49,400
escribió es Y mayúscula,
imprimirá eso.

1323
00:59:49,400 --> 00:59:52,200
Si no, si es N mayúscula,
imprimirá esto.

1324
00:59:52,200 --> 00:59:53,340
No hice nada de eso.

1325
00:59:53,340 --> 00:59:55,720
Así que el programa no está roto per se.

1326
00:59:55,720 --> 00:59:59,130
Solo le falta una
característica, si lo quieren ver así.

1327
00:59:59,130 --> 01:00:00,910
Carece de compatibilidad
con las minúsculas.

1328
01:00:00,910 --> 01:00:04,650
Pero si pongo una Y mayúscula,
por supuesto que funciona.

1329
01:00:04,650 --> 01:00:07,590
¿Por qué está
escrito de esta manera?

1330
01:00:07,590 --> 01:00:10,051
Bueno,
aquí hay un par de detalles.

1331
01:00:10,051 --> 01:00:13,050
Y puede ser una pregunta en la que
se basó su comentario anterior.

1332
01:00:13,050 --> 01:00:19,510
¿Por qué se pone igual, igual,
y no solo igual, como en matemáticas?

1333
01:00:19,510 --> 01:00:20,490
Se ve un poco raro.

1334
01:00:20,490 --> 01:00:21,404
¿Sí?

1335
01:00:21,404 --> 01:00:23,820
PÚBLICO: Un igual es para
asignar valores [INAUDIBLE].

1336
01:00:23,820 --> 01:00:25,110
DAVID: Sí, parece
que es la respuesta.

1337
01:00:25,110 --> 01:00:28,290
Los humanos ya utilizamos
el signo igual con un propósito distinto

1338
01:00:28,290 --> 01:00:29,760
para la asignación, que así se llama.

1339
01:00:29,760 --> 01:00:31,664
Movieron un valor
de derecha a izquierda.

1340
01:00:31,664 --> 01:00:34,830
Así que cuando se dieron cuenta, oh cielos,
quedaron atrapados en su propia trampa.

1341
01:00:34,830 --> 01:00:37,750
¿Cómo comprobamos
la igualdad en aritmética?

1342
01:00:37,750 --> 01:00:40,830
Se necesita un símbolo distinto para
que la computadora sepa la diferencia.

1343
01:00:40,830 --> 01:00:44,750
Así que es igual, igual,
lamentablemente significa igual.

1344
01:00:44,750 --> 01:00:47,255
Igual significa asignaciones.

1345
01:00:47,255 --> 01:00:47,880
Y eso es todo.

1346
01:00:47,880 --> 01:00:50,310
Y una vez que se acuerden de ello,
todo se vuelve muy sencillo,

1347
01:00:50,310 --> 01:00:50,979
pero es por eso.

1348
01:00:50,979 --> 01:00:53,020
Hay otra cosa que hice
un poco diferente.

1349
01:00:53,020 --> 01:00:54,630
Y es un detalle molesto.

1350
01:00:54,630 --> 01:00:58,450
Por qué creen que repentinamente
cambié a caracteres individuales,

1351
01:00:58,450 --> 01:01:00,090
¡diablos!

1352
01:01:00,090 --> 01:01:05,520
¿Por qué, de repente,
cambié a apóstrofes simples en vez

1353
01:01:05,520 --> 01:01:09,228
de comillas dobles, como antes?

1354
01:01:09,228 --> 01:01:12,344
PÚBLICO: Las comillas simples
solo funcionan para los caracteres.

1355
01:01:12,344 --> 01:01:13,260
DAVID: Bueno,sí.

1356
01:01:13,260 --> 01:01:13,980
Qué astuto.

1357
01:01:13,980 --> 01:01:15,630
Sí, así es exactamente.

1358
01:01:15,630 --> 01:01:18,300
Las comillas simples,
como las que acabo de escribir,

1359
01:01:18,300 --> 01:01:22,000
significan que se tienen variables
individuales, en este caso como y o n.

1360
01:01:22,000 --> 01:01:25,230
Las comillas dobles se utilizan cuando hay
varios caracteres para las cadenas en sí.

1361
01:01:25,230 --> 01:01:27,600
Y más adelante
analizaremos la razón de esto.

1362
01:01:27,600 --> 01:01:28,950
Pero por ahora,
esa es la razón.

1363
01:01:28,950 --> 01:01:31,575
Si ustedes revisan un carácter,
esto se hace con comillas simples.

1364
01:01:31,575 --> 01:01:35,640
Si se trata de más de un
carácter, definitivamente

1365
01:01:35,640 --> 01:01:37,810
necesitarán utilizar las comillas
dobles para varios caracteres.

1366
01:01:37,810 --> 01:01:39,060
Pero hay maneras de solucionarlo.

1367
01:01:39,060 --> 01:01:43,540
Ciertamente podría hacer trampa,
y sería como... OK, arreglé mi programa.

1368
01:01:43,540 --> 01:01:45,910
Ahora puedo usar
make noswitch.

1369
01:01:45,910 --> 01:01:47,880
Puedo ejecutar noswitch de nuevo.

1370
01:01:47,880 --> 01:01:50,730
Y ahora puedo escribir y,
y funciona.

1371
01:01:50,730 --> 01:01:55,560
Por desgracia ya no puedo escribir la Y
en mayúscula, así que es un poco tonto.

1372
01:01:55,560 --> 01:02:00,072
¿Cuál creen que sería una
mejor solución para este programa?

1373
01:02:00,072 --> 01:02:01,530
PÚBLICO: [INAUDIBLE] ambas.

1374
01:02:01,530 --> 01:02:02,710
DAVID: Aceptar
ambas de alguna forma.

1375
01:02:02,710 --> 01:02:04,793
Entonces, ¿cómo lo harían
en Scratch, por ejemplo?

1376
01:02:04,793 --> 01:02:05,580
¿Qué es lo que harían?

1377
01:02:05,580 --> 01:02:07,496
¿Cuáles piezas del
rompecabezas utilizarían de nuevo?

1378
01:02:07,496 --> 01:02:08,880
PÚBLICO: Utilizaríamos un or.

1379
01:02:08,880 --> 01:02:10,560
DAVID: OK, podemos utilizar un or.

1380
01:02:10,560 --> 01:02:11,170
Exactamente.

1381
01:02:11,170 --> 01:02:14,070
Así que hay una pieza de rompecabezas,
que podemos, o no, haber utilizado.

1382
01:02:14,070 --> 01:02:16,680
Y me gustaría simplemente
poder escribir la palabra or, pero

1383
01:02:16,680 --> 01:02:19,471
las computadoras son algo
enigmáticas, aunque algunos lenguajes,

1384
01:02:19,471 --> 01:02:22,020
como Python, pueden
introducir de nuevo la palabra or.

1385
01:02:22,020 --> 01:02:24,450
En C existen dos barras verticales.

1386
01:02:24,450 --> 01:02:26,040
Y solo tienen que recordalo.

1387
01:02:26,040 --> 01:02:29,580
Las dos barras verticales permiten decir,
if (c == 'Y'), con mayúscula

1388
01:02:29,580 --> 01:02:33,480
y aquí abajo, puedo decir,
if (c == 'N'), con mayúscula.

1389
01:02:33,480 --> 01:02:35,950
Y ahora puedo
hacer dos preguntas a la vez.

1390
01:02:35,950 --> 01:02:41,790
Y ahora si lo reduzco y lo vuelvo
a compilar, make noswitch, Enter.

1391
01:02:41,790 --> 01:02:47,220
Entonces puedo ejecutar
./noswitch.

1392
01:02:47,220 --> 01:02:52,920
Y ahora puedo poner
y minúscula, Y mayúscula, n minúscula

1393
01:02:52,920 --> 01:02:57,350
y N mayúscula. Pero no puedo
poner un signo de interrogación

1394
01:02:57,350 --> 01:02:59,670
porque no es compatible.

1395
01:02:59,670 --> 01:03:01,940
la s tampoco funciona.

1396
01:03:01,940 --> 01:03:05,070
No fue un carácter
y el último no fue y o n.

1397
01:03:05,070 --> 01:03:07,007
Hay otro modo en el que
podría haber hecho esto.

1398
01:03:07,007 --> 01:03:09,090
¿De qué otra manera podría
haberlo implementado, sobre todo

1399
01:03:09,090 --> 01:03:13,050
si no supiera que existen
estas dos barras verticales?

1400
01:03:13,050 --> 01:03:16,045
¿Qué otra pieza del rompecabezas
o bloque de código podría utilizar?

1401
01:03:16,045 --> 01:03:16,920
AUDIENCIA: [INAUDIBLE]

1402
01:03:16,920 --> 01:03:17,770
DAVID: Sí, exactamente.

1403
01:03:17,770 --> 01:03:19,230
Podía haber utilizado otro else, if.

1404
01:03:19,230 --> 01:03:25,890
Podría decir if el carácter es igual a y,
como hace un momento.

1405
01:03:25,890 --> 01:03:30,300
Pero también podría resultar
if (c == 'Y') mayúscula,

1406
01:03:30,300 --> 01:03:34,510
entonces imprimiré
también printf("yes\ n");

1407
01:03:34,510 --> 01:03:36,180
Y puedo hacer lo mismo para no.

1408
01:03:36,180 --> 01:03:38,277
¿Cómo elegir
entre estas dos opciones?

1409
01:03:38,277 --> 01:03:40,110
Porque esta es solo
la primera de muchas veces

1410
01:03:40,110 --> 01:03:42,109
en las tendrán
que tomar una decisión

1411
01:03:42,109 --> 01:03:43,890
sobre cómo implementar algo.

1412
01:03:43,890 --> 01:03:47,620
¿Alguien tiene un argumento
en favor o en contra de ello?

1413
01:03:47,620 --> 01:03:48,890
¿Un poco más atrás?

1414
01:03:48,890 --> 01:03:50,425
Sí.

1415
01:03:50,425 --> 01:03:53,750
AUDIENCIA: [INAUDIBLE].

1416
01:03:53,750 --> 01:03:56,155
DAVID: Sí, el primero
utilizó menos líneas de código

1417
01:03:56,155 --> 01:03:57,530
y eso es algo bueno.

1418
01:03:57,530 --> 01:04:00,230
Porque entre menos líneas
de código haya, es menos probable

1419
01:04:00,230 --> 01:04:02,390
que tengan errores en sus programas.

1420
01:04:02,390 --> 01:04:05,056
Porque escribieron menos código
y hay menos sitios para cometer errores.

1421
01:04:05,056 --> 01:04:08,450
Y hay otro argumento,
pienso que a favor del primero.

1422
01:04:08,450 --> 01:04:10,446
No solo son menos
líneas de código, ¿qué más hay?

1423
01:04:10,446 --> 01:04:13,175
AUDIENCIA: [INAUDIBLE].

1424
01:04:13,175 --> 01:04:14,050
DAVID: Exacto.

1425
01:04:14,050 --> 01:04:17,230
El segundo también
es redundante, ya que digo

1426
01:04:17,230 --> 01:04:19,720
printf yes dos veces.

1427
01:04:19,720 --> 01:04:22,130
Y eso parece
innecesario, ¿verdad?

1428
01:04:22,130 --> 01:04:24,790
Hemos visto ejemplos en Scratch
donde algo se aplica varias veces

1429
01:04:24,790 --> 01:04:25,610
si se tiene un bucle.

1430
01:04:25,610 --> 01:04:26,943
Bueno, aquí ocurre
lo mismo con las condiciones.

1431
01:04:26,943 --> 01:04:29,660
¿Por qué hago las cosas varias veces
si puedo combinarlas en una?

1432
01:04:29,660 --> 01:04:31,690
Porque además, si luego quieren

1433
01:04:31,690 --> 01:04:35,050
cambiar la salida
a yes, signo de admiración

1434
01:04:35,050 --> 01:04:37,660
podría actualizarse
a medias en muchos lugares

1435
01:04:37,660 --> 01:04:40,360
si hubiera solo
un bloque en vez de dos.

1436
01:04:40,360 --> 01:04:42,457
Pueden estar en desacuerdo
y una persona razonable

1437
01:04:42,457 --> 01:04:44,290
podría argumentar
que no, que esto es más limpio

1438
01:04:44,290 --> 01:04:46,749
porque lo que estamos
revisando ahora es muy explícito.

1439
01:04:46,749 --> 01:04:49,706
Y a eso se reducirá
en un curso como este, en algo

1440
01:04:49,706 --> 01:04:50,590
llamado diseño.

1441
01:04:50,590 --> 01:04:54,220
Habrá correcciones, es decir,
que su código funcione según lo indicado,

1442
01:04:54,220 --> 01:04:55,490
pero, ¿está bien diseñado?

1443
01:04:55,490 --> 01:04:58,420
Una persona
razonable votaría a favor,

1444
01:04:58,420 --> 01:05:01,120
es decir, que sí se hizo un
buen trabajo de implementación.

1445
01:05:01,120 --> 01:05:04,420
Sería el equivalente
de alguien que evalúa un ensayo

1446
01:05:04,420 --> 01:05:07,970
diciendo sí, expresaron sus
pensamientos, pero estaban dispersos.

1447
01:05:07,970 --> 01:05:11,740
Y también hay un tercer eje
de estilo de evaluación.

1448
01:05:11,740 --> 01:05:15,850
Se darán cuenta de que
todo mi código tiene sangrías

1449
01:05:15,850 --> 01:05:18,700
y que hay comentarios
en los archivos que escribí.

1450
01:05:18,700 --> 01:05:20,800
Es una cuestión de
buen estilo, lo cual significa

1451
01:05:20,800 --> 01:05:23,230
que tienen un
código que luce bien y que

1452
01:05:23,230 --> 01:05:27,200
es más fácil de leer que si
escribiéramos todo en una línea.

1453
01:05:27,200 --> 01:05:29,480
Pero veremos
más en un momento.

1454
01:05:29,480 --> 01:05:31,750
A continuación
abriré una alternativa

1455
01:05:31,750 --> 01:05:33,220
y no lo haré desde cero.

1456
01:05:33,220 --> 01:05:36,550
A continuación abriré
un archivo llamado switch.c,

1457
01:05:36,550 --> 01:05:40,060
solo para introducir
otra idea o función.

1458
01:05:40,060 --> 01:05:41,030
Huy.

1459
01:05:41,030 --> 01:05:45,860
OK, fue un accidente
pero es una buena idea.

1460
01:05:45,860 --> 01:05:51,910
¿Qué acabo de hacer y por qué
se ve de esta manera?

1461
01:05:51,910 --> 01:05:53,088
Dí mal un click.

1462
01:05:53,088 --> 01:05:55,230
AUDIENCIA: Abriste el archivo compilado.

1463
01:05:55,230 --> 01:05:59,620
DAVID: Sí, abrí el archivo compilado,
el programa, no el código fuente.

1464
01:05:59,620 --> 01:06:01,790
Así que lo que veo es el código máquina.

1465
01:06:01,790 --> 01:06:05,500
Y dado que mi navegador no conoce su
código máquina, de ceros y unos,

1466
01:06:05,500 --> 01:06:10,660
malinterpreta los ceros y unos
como si fueran caracteres ASCII.

1467
01:06:10,660 --> 01:06:14,500
Recuerden que en ASCII la A mayúscula
es 65, y la B mayúscula es 66.

1468
01:06:14,500 --> 01:06:19,630
El IDE trata de interpretar los ceros
y unos en el código máquina de mi programa

1469
01:06:19,630 --> 01:06:21,100
como si fueran caracteres.

1470
01:06:21,100 --> 01:06:24,070
Pero no es realmente inglés, o
no se trata de la sintaxis del inglés.

1471
01:06:24,070 --> 01:06:26,270
Son solo ceros y unos
aleatorios en cierto sentido.

1472
01:06:26,270 --> 01:06:28,895
Y por eso estamos viendo
caracteres y colores locos.

1473
01:06:28,895 --> 01:06:31,477
Porque son malinterpretados
como colores o caracteres

1474
01:06:31,477 --> 01:06:32,560
que yo no escribí.

1475
01:06:32,560 --> 01:06:33,430
Así que no se preocupen.

1476
01:06:33,430 --> 01:06:35,170
Ignoren el problema y ciérrenlo.

1477
01:06:35,170 --> 01:06:39,010
Y luego abran switch.c.

1478
01:06:39,010 --> 01:06:42,850
Esta no es una característica
de Scratch, pero sirve para demostrar,

1479
01:06:42,850 --> 01:06:46,570
incluso en C, que hay
más formas de aplicar la misma idea.

1480
01:06:46,570 --> 01:06:48,430
Me desplazaré un poco hacia arriba.

1481
01:06:48,430 --> 01:06:52,750
Y verán que en la parte superior
del archivo tengo main como antes.

1482
01:06:52,750 --> 01:06:55,120
Pongo el cursor en el
usuario para un carácter.

1483
01:06:55,120 --> 01:06:57,684
Pero esta vez
no utilizo if ni else.

1484
01:06:57,684 --> 01:07:02,660
Noten que uso una nueva palabra clave
que no existe en Scratch, llamada switch.

1485
01:07:02,660 --> 01:07:06,640
Se pone entre paréntesis,
es una variable que desean ver

1486
01:07:06,640 --> 01:07:09,070
y una variable o valor
con la que desean

1487
01:07:09,070 --> 01:07:12,280
tomar decisiones, según
sus bases para tomar decisiones.

1488
01:07:12,280 --> 01:07:15,190
Y parece que tenemos
cuatro casos aquí, los cuales

1489
01:07:15,190 --> 01:07:18,370
son más atractivos
de lo que aparentan.

1490
01:07:18,370 --> 01:07:21,760
¿Qué hace este programa
cuando se ejecuta?

1491
01:07:21,760 --> 01:07:24,990
Aunque nunca antes hayamos
visto una oración con switch.

1492
01:07:24,990 --> 01:07:28,540

1493
01:07:28,540 --> 01:07:31,622
¿Qué parece hacer?

1494
01:07:31,622 --> 01:07:33,536
¿Qué es eso?

1495
01:07:33,536 --> 01:07:35,410
PÚBLICO: En diferentes casos,
hay diferentes opciones.

1496
01:07:35,410 --> 01:07:37,660
DAVID: Sí, diferentes
casos, diferentes opciones.

1497
01:07:37,660 --> 01:07:40,220
Así que, si escribo una Y mayúscula
para este programa cuando se ejecuta,

1498
01:07:40,220 --> 01:07:41,950
¿Qué pasará?

1499
01:07:41,950 --> 01:07:42,950
Imprimirá yes.

1500
01:07:42,950 --> 01:07:44,674
¿Y si escribo una N mayúscula?

1501
01:07:44,674 --> 01:07:45,590
PÚBLICO: [INAUDIBLE].

1502
01:07:45,590 --> 01:07:46,310
DAVID: ¿n minúscula?

1503
01:07:46,310 --> 01:07:47,240
PÚBLICO: [INAUDIBLE].

1504
01:07:47,240 --> 01:07:47,690
DAVID: Y así sucesivamente.

1505
01:07:47,690 --> 01:07:49,391
De hecho es exactamente
el mismo programa,

1506
01:07:49,391 --> 01:07:51,140
solo que se escribió con
una función diferente,

1507
01:07:51,140 --> 01:07:53,181
entonces existen diferentes modos
en los que pueden expresarse,

1508
01:07:53,181 --> 01:07:56,865
como si dos personas tuvieran
la misma opinión en un caso judicial.

1509
01:07:56,865 --> 01:07:58,740
Puede que tengan las
mismas opiniones, pero ellas

1510
01:07:58,740 --> 01:08:00,740
se expresarán en inglés
de diferente manera.

1511
01:08:00,740 --> 01:08:03,885
Así que en C, pueden escribir el mismo
programa, se comportará exactamente igual,

1512
01:08:03,885 --> 01:08:07,010
pero usarán un enfoque diferente
con distintas construcciones

1513
01:08:07,010 --> 01:08:07,910
como switches.

1514
01:08:07,910 --> 01:08:11,029
Y este es el caso con la Y
mayúscula y la y minúscula,

1515
01:08:11,029 --> 01:08:14,779
solo significa que si se presenta
cualquiera de estos dos casos,

1516
01:08:14,779 --> 01:08:16,279
se debe insertar
el código debajo de ellas.

1517
01:08:16,279 --> 01:08:17,380
Pero después se interrumpe.

1518
01:08:17,380 --> 01:08:21,590
Si se interrumpe, deben asegurarse de que
no se siga ejecutando lo que está debajo.

1519
01:08:21,590 --> 01:08:23,870
Porque si no tiene una
interrupción, el programa

1520
01:08:23,870 --> 01:08:25,760
continuará ejecutando las
líneas del código que están debajo.

1521
01:08:25,760 --> 01:08:27,800
Y si he escrito y, podría
decir de manera incorrecta

1522
01:08:27,800 --> 01:08:31,130
yes, no, porque no le dije
que se detuviera.

1523
01:08:31,130 --> 01:08:33,710
Pueden obtener interrupciones
libremente con los condicionales If

1524
01:08:33,710 --> 01:08:35,240
porque tenemos esas llaves.

1525
01:08:35,240 --> 01:08:37,580
El switch no utiliza
llaves en su interior,

1526
01:08:37,580 --> 01:08:39,439
sino una sintaxis
ligeramente distinta.

1527
01:08:39,439 --> 01:08:40,419
¿Cuál es la mejor?

1528
01:08:40,419 --> 01:08:41,210
Depende.

1529
01:08:41,210 --> 01:08:44,689
Algunas veces, parece mejor
[INAUDIBLE] el switch en cierto sentido,

1530
01:08:44,689 --> 01:08:45,790
una persona razonable podría
decir [INAUDIBLE] una mejor

1531
01:08:46,290 --> 01:08:48,160
versión del programa
que acabamos de escribir.

1532
01:08:48,160 --> 01:08:50,520
Porque véanlo, es
mucho más compacto, ¿cierto?

1533
01:08:50,520 --> 01:08:52,410
Es más fácil de digerir visualmente.

1534
01:08:52,410 --> 01:08:53,970
Escribí menos caracteres.

1535
01:08:53,970 --> 01:08:57,450
Pero quizás alguien no esté de acuerdo
y diga, yo rara vez utilizo switches,

1536
01:08:57,450 --> 01:08:58,840
nunca recuerdo cómo funcionan.

1537
01:08:58,840 --> 01:09:00,750
Esto es menos legible para mí.

1538
01:09:00,750 --> 01:09:03,300
Entonces, se trata
del estilo de cada persona

1539
01:09:03,300 --> 01:09:07,000
en casos como este,
cuando se trata de diseños.

1540
01:09:07,000 --> 01:09:07,710
Muy bien.

1541
01:09:07,710 --> 01:09:11,220
Vamos a introducir otra idea,
otro bloque de construcciones

1542
01:09:11,220 --> 01:09:14,028
que hemos visto antes,
pero que no hemos aplicado.

1543
01:09:14,028 --> 01:09:15,819
Para continuar
haremos lo siguiente.

1544
01:09:15,819 --> 01:09:18,359
Voy a crear un programa
que se llamará return.c,

1545
01:09:18,359 --> 01:09:22,770
así puedo poner en práctica
la idea que Sam actuó para nosotros.

1546
01:09:22,770 --> 01:09:25,830
A continuación
incluiré la biblioteca del CS50

1547
01:09:25,830 --> 01:09:28,770
y después voy a
incluir la biblioteca estándar.

1548
01:09:28,770 --> 01:09:32,819
Después pondré este
int main(void), como antes.

1549
01:09:32,819 --> 01:09:36,720
Y luego, aquí abajo, pondré
int x = get_int("x: );

1550
01:09:36,720 --> 01:09:39,149
Y señalaré
al usuario con la x.

1551
01:09:39,149 --> 01:09:43,350
Y entonces diré
printf("%i\ n")...

1552
01:09:43,350 --> 01:09:45,300
Y ahora quiero el cuadrado de x
printf("%i\ n", x*x)

1553
01:09:45,300 --> 01:09:49,120
Porque x veces por sí misma
me dará x al cuadrado.

1554
01:09:49,120 --> 01:09:50,410
Ahora es muy sencillo.

1555
01:09:50,410 --> 01:09:52,368
No es un programa difícil
de escribir, especialmente

1556
01:09:52,368 --> 01:09:53,850
una vez que se conoce la multiplicación.

1557
01:09:53,850 --> 01:09:55,690
Y esto parece hacer exactamente eso.

1558
01:09:55,690 --> 01:09:59,670
Si escriben 2, me da 2 al cuadrado,
igual a cuatro, y así sucesivamente.

1559
01:09:59,670 --> 01:10:03,070
Pero ya saben, el cuadrado es
una función que me gusta mucho usar,

1560
01:10:03,070 --> 01:10:03,570
¿verdad?

1561
01:10:03,570 --> 01:10:05,200
Es como una operación matemática.

1562
01:10:05,200 --> 01:10:09,420
Y sí, claro que es trivial
implementarlo con x veces x.

1563
01:10:09,420 --> 01:10:12,390
Pero sería bueno
abstraernos y solo decir

1564
01:10:12,390 --> 01:10:13,530
la palabra square.

1565
01:10:13,530 --> 01:10:17,280
Bueno, si su lenguaje de
programación no viene con una función

1566
01:10:17,280 --> 01:10:19,210
llamada square,
no hay mucho problema.

1567
01:10:19,210 --> 01:10:20,460
Podemos implementarla
nosotros mismos.

1568
01:10:20,460 --> 01:10:21,960
Podemos hacerlo
de la siguiente manera.

1569
01:10:21,960 --> 01:10:24,240
Entonces
escribiré lo siguiente.

1570
01:10:24,240 --> 01:10:30,450
int square(int n)

1571
01:10:30,450 --> 01:10:34,410
Y luego aquí,
return n * n;

1572
01:10:34,410 --> 01:10:35,534
¿Qué acabo de hacer?

1573
01:10:35,534 --> 01:10:37,950
Es posible que no hayan hecho
esto en sus programas de Scratch,

1574
01:10:37,950 --> 01:10:40,140
pero tal vez recuerden
que en la última clase,

1575
01:10:40,140 --> 01:10:42,750
dimos un ejemplo sobre la tos, con una
pieza del rompecabezas personalizada

1576
01:10:42,750 --> 01:10:44,430
era una pieza
de rompecabezas morada.

1577
01:10:44,430 --> 01:10:47,310
La tos no era un bloque que existiera
cuando mi equipo lo hizo en Scratch

1578
01:10:47,310 --> 01:10:48,360
pero lo creamos.

1579
01:10:48,360 --> 01:10:51,917
Es posible que square no exista en C,
en las bibliotecas que estamos usando.

1580
01:10:51,917 --> 01:10:53,000
Así que lo construiremos.

1581
01:10:53,000 --> 01:10:54,160
¿Cómo lo hacemos?

1582
01:10:54,160 --> 01:10:56,666
Bueno, podemos comenzar
por solucionar en parte

1583
01:10:56,666 --> 01:10:59,790
la pregunta que surgió antes sobre
int y void, aunque solo parcialmente

1584
01:10:59,790 --> 01:11:00,840
por hoy.

1585
01:11:00,840 --> 01:11:02,270
Este es el nombre de mi función.

1586
01:11:02,270 --> 01:11:04,800
Es mi pieza de rompecabezas
personalizada, si quieren verlo así.

1587
01:11:04,800 --> 01:11:09,420
Toma como entrada, con los
paréntesis, un valor que arbitrariamente

1588
01:11:09,420 --> 01:11:10,290
llamaré n.

1589
01:11:10,290 --> 01:11:13,270
Podría llamarlo
m, o, p, o lo que quieran.

1590
01:11:13,270 --> 01:11:17,730
Pero n representa un número, así que tomé
n, como cualquier especialista en sistemas.

1591
01:11:17,730 --> 01:11:21,180
Y todo lo que hace es
ejecutar una línea de código.

1592
01:11:21,180 --> 01:11:23,130
n veces n,

1593
01:11:23,130 --> 01:11:24,790
pero entonces
devuelve el valor.

1594
01:11:24,790 --> 01:11:26,610
Y en especial, esta palabra
clave que está resaltada aquí,

1595
01:11:26,610 --> 01:11:29,220
es parecida a la que Sam
me devolvió en una hoja de papel.

1596
01:11:29,220 --> 01:11:32,330
Él me devolvió
un valor en una hoja de papel.

1597
01:11:32,330 --> 01:11:35,670
Aquí devuelve n veces n.

1598
01:11:35,670 --> 01:11:40,630
Y eso implica, ¿qué tipo de datos
devuelve esta función personalizada

1599
01:11:40,630 --> 01:11:43,290
a quien la usa?

1600
01:11:43,290 --> 01:11:45,810
Es un entero, porque n es un entero.

1601
01:11:45,810 --> 01:11:48,120
Y resulta lógico que
n veces n sea un número entero.

1602
01:11:48,120 --> 01:11:52,740
Esa es la razón por la cual
también especifiqué a int aquí.

1603
01:11:52,740 --> 01:11:56,640
Resulta que las funciones, para
ser más claros, pueden tomar entradas

1604
01:11:56,640 --> 01:11:58,410
y pueden devolver salidas.

1605
01:11:58,410 --> 01:12:00,810
Si toman entradas, estas
deben ponerse entre paréntesis,

1606
01:12:00,810 --> 01:12:03,030
como las que he
resaltado aquí, en la línea 10.

1607
01:12:03,030 --> 01:12:07,080
Y en este caso se trata de una entrada,
una variable llamada n de tipo int.

1608
01:12:07,080 --> 01:12:11,370
Pero esta función también, al igual que
la implementación de Sam con get_string

1609
01:12:11,370 --> 01:12:13,900
devuelve un valor,
no una cadena sino un entero.

1610
01:12:13,900 --> 01:12:16,500
Entonces tengo que decir a la computadora,
hey, esta función personalizada

1611
01:12:16,500 --> 01:12:20,820
que acabo de escribir devolverá
un número entero a quien la utilice.

1612
01:12:20,820 --> 01:12:23,580
Y es esta línea del código,
la línea 12, la que realmente

1613
01:12:23,580 --> 01:12:28,500
implementa la funcionalidad de la
cual se obtiene el valor que interesa.

1614
01:12:28,500 --> 01:12:34,100
De modo que ya no necesito
repetir esto ni reinventar la rueda.

1615
01:12:34,100 --> 01:12:37,670
Ahora puedo utilizar square como una
palabra clave en todos mis programas.

1616
01:12:37,670 --> 01:12:39,950
Pero, ¿cómo la llamamos?

1617
01:12:39,950 --> 01:12:43,670
Hasta ahora, cada vez que he nombrado
funciones, lo hago de esta manera.

1618
01:12:43,670 --> 01:12:47,060
int squaredvalue =...

1619
01:12:47,060 --> 01:12:49,796
Y luego podría ponerle
int squaredvalue = square(x);

1620
01:12:49,796 --> 01:12:51,920
Pero hago esto
de manera intuitiva, ¿cierto?

1621
01:12:51,920 --> 01:12:54,620
No sé si es lo mejor,
pero hace que siga un patrón.

1622
01:12:54,620 --> 01:12:58,339
En el lado izquierdo, declaré
una variable llamada squaredvalue,

1623
01:12:58,339 --> 01:12:59,630
aunque es un
nombre algo pretencioso.

1624
01:12:59,630 --> 01:13:00,796
Probablemente
podríamos usar algo mejor.

1625
01:13:00,796 --> 01:13:02,780
Pero squaredvalue
es un tipo de entero.

1626
01:13:02,780 --> 01:13:05,969
En el lado derecho lo llamo square,

1627
01:13:05,969 --> 01:13:07,760
pongo su nombre, abro paréntesis

1628
01:13:07,760 --> 01:13:09,509
y luego introduzco el valor de entrada,

1629
01:13:09,509 --> 01:13:13,157
del mismo modo en que le entregué a Sam
un pedazo de papel con los datos.

1630
01:13:13,157 --> 01:13:15,740
Y entonces regreso ese valor
de derecha a izquierda.

1631
01:13:15,740 --> 01:13:18,830
Luego utilizo el operador de
asignación, simplemente el signo igual.

1632
01:13:18,830 --> 01:13:22,520
Entonces, ¿cómo puedo mejorar
la línea 8 para finalizar esta idea?

1633
01:13:22,520 --> 01:13:26,150
En vez de escribir x veces x,
¿qué debo escribir aquí simplemente?

1634
01:13:26,150 --> 01:13:28,975
Pues squaredvalue, lo cual es
un poco tonto ahora que he

1635
01:13:28,975 --> 01:13:31,670
añadido más caracteres y que
he logrado exactamente lo mismo.

1636
01:13:31,670 --> 01:13:33,920
Pero no necesito este valor
intermedio y aquí tenemos

1637
01:13:33,920 --> 01:13:36,080
una oportunidad
para mejorar el diseño.

1638
01:13:36,080 --> 01:13:40,790
Si en la línea 7 únicamente
declaro una variable

1639
01:13:40,790 --> 01:13:45,020
y luego la uso de inmediato en la línea 8,
entonces no es necesario que exista,

1640
01:13:45,020 --> 01:13:48,450
porque pueden anidar bloques
de código de la siguiente manera.

1641
01:13:48,450 --> 01:13:52,850
Puedo tomar square de x, el cual sé
que nos devuelve el cuadrado de x.

1642
01:13:52,850 --> 01:13:55,010
Puedo borrar la línea 7 por completo.

1643
01:13:55,010 --> 01:13:59,120
Y puedo hacer esto aún más elegante,
así como también se pueden anidar las piezas.

1644
01:13:59,120 --> 01:14:01,410
Y podría decirse
que tiene un mejor diseño

1645
01:14:01,410 --> 01:14:03,150
porque tiene menos líneas de código.

1646
01:14:03,150 --> 01:14:04,370
Solamente dice lo que hace.

1647
01:14:04,370 --> 01:14:08,660
Y no tendrán ninguna variable aleatoria
temporal que vaya de una línea

1648
01:14:08,660 --> 01:14:09,200
hacia el texto.

1649
01:14:09,200 --> 01:14:11,677
Tal vez sea menos legible,
cada persona tiene su propio estilo,

1650
01:14:11,677 --> 01:14:13,010
pero al menos ahora tengo esto.

1651
01:14:13,010 --> 01:14:15,260
Aunque hay un problema.

1652
01:14:15,260 --> 01:14:21,440
Incluso si todo esto tiene sentido, o si es
súper nuevo para muchos de ustedes,

1653
01:14:21,440 --> 01:14:23,670
Tengo un error.

1654
01:14:23,670 --> 01:14:24,620
Cometí un error.

1655
01:14:24,620 --> 01:14:26,660
¿Y cómo puedo solucionarlo?

1656
01:14:26,660 --> 01:14:30,155
La declaración implícita de la función
"square" es inválida en C99.

1657
01:14:30,155 --> 01:14:34,389
C99 significa que es la versión
de 1999 de un lenguaje llamado C.

1658
01:14:34,389 --> 01:14:35,680
La declaración
implícita de la función square.

1659
01:14:35,680 --> 01:14:38,360
Bueno, aún no lo
hemos dicho explícitamente,

1660
01:14:38,360 --> 01:14:39,710
pero C es un poco tonto.

1661
01:14:39,710 --> 01:14:42,150
Solo hace lo que
se le pide que haga.

1662
01:14:42,150 --> 01:14:47,540
Y por desgracia,
y esto es un error, en la línea 7

1663
01:14:47,540 --> 01:14:50,870
llamo a la función square
mencionando su nombre.

1664
01:14:50,870 --> 01:14:55,070
Por desgracia, ¿en cuál línea de código
enseño a la computadora que square

1665
01:14:55,070 --> 01:14:57,290
siquiera existe?

1666
01:14:57,290 --> 01:14:59,950
No hasta unas líneas después,
en la línea 10 y posteriores.

1667
01:14:59,950 --> 01:15:01,040
Así que es demasiado tarde.

1668
01:15:01,040 --> 01:15:04,640
Traté de utilizar square
incluso antes de existiera.

1669
01:15:04,640 --> 01:15:06,990
Pero puedo arreglarlo
en un par de formas.

1670
01:15:06,990 --> 01:15:12,860
Puedo tomar este bloque de
código, moverlo y guardarlo otra vez.

1671
01:15:12,860 --> 01:15:14,900
Y ejecutar make return y funciona.

1672
01:15:14,900 --> 01:15:16,567
Pero es como el juego del gato y el ratón.

1673
01:15:16,567 --> 01:15:19,733
Con el tiempo verán que
sus programas se complican bastante,

1674
01:15:19,733 --> 01:15:22,190
no podrán mover cada función
por encima de las otras funciones.

1675
01:15:22,190 --> 01:15:23,960
En algún momento,
construirán un escenario

1676
01:15:23,960 --> 01:15:26,790
donde ninguna función
puede estar por encima de otra.

1677
01:15:26,790 --> 01:15:27,710
Pero eso está bien.

1678
01:15:27,710 --> 01:15:33,050
Porque también podemos deshacer
esto y escribir square en la parte inferior

1679
01:15:33,050 --> 01:15:35,450
y mantener main en la parte superior,
lo cual es la mejor opción.

1680
01:15:35,450 --> 01:15:38,427
Es mejor mantenerlo en la parte superior
ya que es la función predeterminada

1681
01:15:38,427 --> 01:15:40,010
que al humano le interesa.

1682
01:15:40,010 --> 01:15:43,670
Y puedo ser algo redundante,

1683
01:15:43,670 --> 01:15:45,360
pero está bien en este caso.

1684
01:15:45,360 --> 01:15:49,910
Puedo darle al compilador, clang
en este caso, una pista de lo que vendrá.

1685
01:15:49,910 --> 01:15:51,790
No tengo que decirle
cómo se implementa.

1686
01:15:51,790 --> 01:15:54,800
Pero en la línea 4, puedo usar
algo llamado prototipo.

1687
01:15:54,800 --> 01:15:57,740
Un pequeño avance, parecido al trailer
de una película, de la función que

1688
01:15:57,740 --> 01:15:59,510
finalmente se implementará.

1689
01:15:59,510 --> 01:16:02,150
Todo lo que clang debe
saber desde el principio

1690
01:16:02,150 --> 01:16:04,520
es, cuáles son
sus entradas y sus salidas.

1691
01:16:04,520 --> 01:16:07,680
La implementación entre
llaves puede ponerse más tarde.

1692
01:16:07,680 --> 01:16:10,460
Entonces, si pongo
return otra vez, el programa

1693
01:16:10,460 --> 01:16:13,550
parece compilar con éxito,
puedo escribir ./return

1694
01:16:13,550 --> 01:16:17,540
Y luego, si pongo
que x es 3, el cuadrado de x

1695
01:16:17,540 --> 01:16:20,210
será 9 en este caso.

1696
01:16:20,210 --> 01:16:23,330
Y podemos hacer estas abstracciones
en muchos contextos diferentes

1697
01:16:23,330 --> 01:16:26,660
implementando ideas como
el cuadrado, y entonces llamarlo

1698
01:16:26,660 --> 01:16:29,090
por su nombre, square,
pero no se preocuparán

1699
01:16:29,090 --> 01:16:31,310
por cómo se implementó.

1700
01:16:31,310 --> 01:16:34,280
Lamentablemente,
chocaremos con algunos límites.

1701
01:16:34,280 --> 01:16:36,600
Chocaremos con algunos
límites como el que sigue.

1702
01:16:36,600 --> 01:16:38,621
Para continuar,
les recordaré un visual

1703
01:16:38,621 --> 01:16:40,620
que posiblemente no han visto
dentro de su computadora

1704
01:16:40,620 --> 01:16:41,390
Y es el siguiente.

1705
01:16:41,390 --> 01:16:44,690
De hecho, dentro de sus Mac, PC,
laptops, o incluso de sus teléfonos,

1706
01:16:44,690 --> 01:16:45,710
hay cosas como esta.

1707
01:16:45,710 --> 01:16:47,570
Estas son placas de RAM o de memoria.

1708
01:16:47,570 --> 01:16:50,960
Cuando digo que mi computadora
tiene uno o dos gigabytes de memoria,

1709
01:16:50,960 --> 01:16:52,460
generalmente tiene una
o más de estas cosas.

1710
01:16:52,460 --> 01:16:53,870
Y podrían tener formas
ligeramente diferentes.

1711
01:16:53,870 --> 01:16:55,830
Por ejemplo,
esta proviene de una laptop.

1712
01:16:55,830 --> 01:16:58,788
Y hay otras cosas dentro de sus
computadoras que también tienen límites.

1713
01:16:58,788 --> 01:17:00,710
Pero por ahora,
solo nos interesa esto.

1714
01:17:00,710 --> 01:17:02,120
Se trata de un dispositivo físico.

1715
01:17:02,120 --> 01:17:05,540
Almacena ceros y unos cuando
sus computadoras están funcionando.

1716
01:17:05,540 --> 01:17:09,230
Cuando dan doble clic en un icono de
Mac OS o Windows, y cargan un programa,

1717
01:17:09,230 --> 01:17:12,710
estudian matemáticas o escriben un ensayo,
eso se almacena en este hardware físico

1718
01:17:12,710 --> 01:17:14,130
como ceros y unos.

1719
01:17:14,130 --> 01:17:19,220
Pero la ram, la memoria que tenemos
en nuestras computadoras, es finita.

1720
01:17:19,220 --> 01:17:22,500
Esta mide solo algunas pulgadas
por algunas pulgadas.

1721
01:17:22,500 --> 01:17:26,450
Solo almacena cierta cantidad
de millones o miles de millones de bits,

1722
01:17:26,450 --> 01:17:27,110
y eso es todo.

1723
01:17:27,110 --> 01:17:29,930
Entonces tenemos
una cantidad fija de memoria.

1724
01:17:29,930 --> 01:17:32,960
Eso no es bueno cuando
se trata de escribir programas

1725
01:17:32,960 --> 01:17:35,199
en los que no se sabe previamente
qué tan grandes serán los números

1726
01:17:35,199 --> 01:17:36,740
que los humanos escribirán.

1727
01:17:36,740 --> 01:17:39,500
O qué tan largo será
un ensayo escrito por un humano.

1728
01:17:39,500 --> 01:17:43,430
Sin duda se podría idear un escenario
donde el ensayo sea solo pura palabrería

1729
01:17:43,430 --> 01:17:45,800
que no quepa en
la memoria de la computadora.

1730
01:17:45,800 --> 01:17:48,530
O que su número
tenga tantos dígitos,

1731
01:17:48,530 --> 01:17:52,520
que no quepa en la memoria
de la computadora, porque es fija.

1732
01:17:52,520 --> 01:17:53,990
Solo se tiene una cantidad finita.

1733
01:17:53,990 --> 01:17:57,980
Y esto trae consecuencias muy serias
para al menos dos problemas.

1734
01:17:57,980 --> 01:18:00,420
Existe algo bastante esotérico,
que se llama desbordamiento de enteros,

1735
01:18:00,420 --> 01:18:02,420
y se puede ver
de vez en cuando

1736
01:18:02,420 --> 01:18:04,460
en los medios de comunicación,
como un problema del mundo real.

1737
01:18:04,460 --> 01:18:06,410
Aquí, por ejemplo, hay 8 bits.

1738
01:18:06,410 --> 01:18:08,780
La última vez observamos
solo tres, pero aquí hay ocho.

1739
01:18:08,780 --> 01:18:10,820
Y si lo notan, es un
número bastante elevado.

1740
01:18:10,820 --> 01:18:11,990
Son muchos unos.

1741
01:18:11,990 --> 01:18:14,630
Y esto sucede, si hacen los
cálculos de la última vez,

1742
01:18:14,630 --> 01:18:17,420
para representar 254.

1743
01:18:17,420 --> 01:18:20,190
¿Qué sucede si
incremento este número en 1?

1744
01:18:20,190 --> 01:18:23,531
¿Qué cambios ocurren,
según la última lección?

1745
01:18:23,531 --> 01:18:24,530
Sí, lo más correcto.

1746
01:18:24,530 --> 01:18:25,970
El 0 se convierte en 1.

1747
01:18:25,970 --> 01:18:27,800
Y luego todos
se convierten en unos,

1748
01:18:27,800 --> 01:18:32,510
lo que sucede es que si
se cuentan 255 lugares.

1749
01:18:32,510 --> 01:18:37,490
Si a esto le sumamos 1 más,
¿qué ocurre?

1750
01:18:37,490 --> 01:18:40,610
En el mundo humano, idealmente
tomaríamos un marcador o un gis

1751
01:18:40,610 --> 01:18:41,810
y escribiríamos un número más.

1752
01:18:41,810 --> 01:18:45,380
Pero en el mundo de las computadoras,
si solo tienen una cantidad fija de memoria,

1753
01:18:45,380 --> 01:18:47,210
que con suerte es mayor a 8 bits,

1754
01:18:47,210 --> 01:18:50,210
podría haber millones o miles de
millones, y en algún momento se agotará.

1755
01:18:50,210 --> 01:18:54,980
De hecho, todos los tipos de datos de
los que hablamos hoy, como ints, chars

1756
01:18:54,980 --> 01:18:57,950
y floats utilizan
un número finito de bits,

1757
01:18:57,950 --> 01:19:01,190
que por lo general
es 8, 16, 32 o 64.

1758
01:19:01,190 --> 01:19:06,080
Es una potencia de dos pero fija,
es decir un programa de computadora

1759
01:19:06,080 --> 01:19:09,320
usa ints, chars y floats
para contar un número muy alto,

1760
01:19:09,320 --> 01:19:12,019
mientras que los humanos, en teoría,
podemos contar hasta el infinito.

1761
01:19:12,019 --> 01:19:14,060
Y el problema es,
si se tiene una serie como esta

1762
01:19:14,060 --> 01:19:18,770
que ya es lo más grande posible, con todos
los bits 1, todos los focos prendidos,

1763
01:19:18,770 --> 01:19:20,900
si se le agrega uno más

1764
01:19:20,900 --> 01:19:23,460
y ya no cabe ni uno,

1765
01:19:23,460 --> 01:19:26,000
entonces todos esos valores,
de pronto se convertirán en 0

1766
01:19:26,000 --> 01:19:28,580
y los enteros se desbordarán.

1767
01:19:28,580 --> 01:19:34,400
Se obtiene el 255, y qué creen que siga
después del 255, si solo se tienen 8 bits.

1768
01:19:34,400 --> 01:19:37,770
Cero, aparentemente, porque todos
los 1 cambian y se convierten en 0.

1769
01:19:38,370 --> 01:19:43,140
Entonces, una computadora solo
puede contar tan alto usando un int,

1770
01:19:43,140 --> 01:19:44,220
un float o un double.

1771
01:19:44,220 --> 01:19:46,770
Y en algún momento,
si se intenta añadir uno más,

1772
01:19:46,770 --> 01:19:49,100
los números se
desbordarán y terminarán

1773
01:19:49,100 --> 01:19:50,850
siendo algo que no se espera.

1774
01:19:50,850 --> 01:19:54,970
Tal vez sea positivo, tal vez
negativo, o tal vez termine siendo 0.

1775
01:19:54,970 --> 01:19:56,230
Y de hecho podemos verlo.

1776
01:19:56,230 --> 01:19:59,220
Para mostrarlo
abriré un programa llamado

1777
01:19:59,220 --> 01:20:05,820
Overflow, que está disponible
en línea, y que literalmente hace esto

1778
01:20:05,820 --> 01:20:06,930
si lo ejecuto.

1779
01:20:06,930 --> 01:20:09,960
Make overflow.

1780
01:20:09,960 --> 01:20:12,480
./overflow.

1781
01:20:12,480 --> 01:20:18,840
Conforme ejecuto este
programa, contará de 1, a 2, a 4,

1782
01:20:18,840 --> 01:20:20,370
a 8, a 16.

1783
01:20:20,370 --> 01:20:22,950
Simplemente escribí
un programa que duplica

1784
01:20:22,950 --> 01:20:25,200
el número en cada iteración del bucle.

1785
01:20:25,200 --> 01:20:27,075
Y también utilicé
otra función llamada sleep

1786
01:20:27,075 --> 01:20:28,949
de modo que esto
no se salga de la pantalla.

1787
01:20:28,949 --> 01:20:30,750
Quería hacer
una pausa, como en Scratch.

1788
01:20:30,750 --> 01:20:31,590
Pueden esperar.

1789
01:20:31,590 --> 01:20:34,180
Se vuelve cada vez más grande
y más grande, y esto es exponencial.

1790
01:20:34,180 --> 01:20:35,910
Así que se volverá más grande y
más grande mucho más rápido, lo cual

1791
01:20:35,910 --> 01:20:37,410
es bueno porque
no tardará eternamente

1792
01:20:37,410 --> 01:20:39,060
para alcanzar un número muy grande.

1793
01:20:39,060 --> 01:20:40,260
Pero estoy usando un entero.

1794
01:20:40,260 --> 01:20:43,020
Y con un entero solo se puede contar,
aproximadamente, hasta 4 mil millones

1795
01:20:43,020 --> 01:20:46,530
y técnicamente solo hasta 2 mil millones
si quieren también números negativos,

1796
01:20:46,530 --> 01:20:49,110
si desean que la mitad
sea negativa y la mitad positiva.

1797
01:20:49,110 --> 01:20:50,160
Y ahí está.

1798
01:20:50,160 --> 01:20:55,830
Eventualmente, si hablo lo suficiente,
duplicaré este entero tantas veces

1799
01:20:55,830 --> 01:20:58,620
que simplemente no cabrá
en 32 bits y la computadora me avisará

1800
01:20:58,620 --> 01:20:59,842
con un error
en el tiempo de ejecución.

1801
01:20:59,842 --> 01:21:01,050
Y luego pasarán cosas extrañas.

1802
01:21:01,050 --> 01:21:03,000
Ahora estoy atascado en 0.

1803
01:21:03,000 --> 01:21:04,800
Y ahora ven
realmente como sucede.

1804
01:21:04,800 --> 01:21:08,430
Pero también hay un otro problema
y se trata de un programa super sencillo

1805
01:21:08,430 --> 01:21:11,790
que no pensarían que pudiera
presentar errores, pero lo hace.

1806
01:21:11,790 --> 01:21:14,830
A continuación escribiré
rápidamente un programa

1807
01:21:14,830 --> 01:21:17,690
que incluya la biblioteca estándar.

1808
01:21:17,690 --> 01:21:19,760
Int main(void), como antes.

1809
01:21:19,760 --> 01:21:23,996
Guardaré esto como una imprecisión,
como un problema diferente,

1810
01:21:23,996 --> 01:21:24,495
.c

1811
01:21:24,495 --> 01:21:25,950
Y simplemente haré lo siguiente.

1812
01:21:25,950 --> 01:21:31,120
printf("%f\ n", 1-0 / 10.0);

1813
01:21:31,120 --> 01:21:35,010
...con 1.0 dividido por 10.0.

1814
01:21:35,010 --> 01:21:38,414
Ahora, según lo que aprendieron en
la primaria, ¿Cuál sería la respuesta?

1815
01:21:38,414 --> 01:21:39,330
PÚBLICO: 0.1.

1816
01:21:39,330 --> 01:21:40,410
DAVID: 0.1.

1817
01:21:40,410 --> 01:21:41,530
Eso es el 10%.

1818
01:21:41,530 --> 01:21:42,240
0.1.

1819
01:21:42,240 --> 01:21:45,300
Y si continúo y
ejecuto ./imprecision.

1820
01:21:45,300 --> 01:21:49,440
Y esto sería 0.10000,
lo cual es lo mismo.

1821
01:21:49,440 --> 01:21:55,620
Pero estoy dispuesto a apostar
un dólar a que nos han mentido a todos.

1822
01:21:55,620 --> 01:22:00,710
Ya que 1 dividido entre
10 realmente no es 0.1.

1823
01:22:00,710 --> 01:22:02,349
¿Alguien quiere apostar?

1824
01:22:02,349 --> 01:22:04,640
Debería haber afirmado esto
antes de sacar el dólar.

1825
01:22:04,640 --> 01:22:05,990
Lo siento, ya mostré mis cartas.

1826
01:22:05,990 --> 01:22:08,690
Hago esta afirmación
debido a lo siguiente.

1827
01:22:08,690 --> 01:22:10,965
Tal vez no estoy buscando
lo suficiente dentro del número,

1828
01:22:10,965 --> 01:22:14,090
cuando pregunté antes cómo
podíamos mostrar más dígitos decimales,

1829
01:22:14,090 --> 01:22:15,170
déjenme ver 10 de ellos,

1830
01:22:15,170 --> 01:22:16,586
déjenme tener algo de consuelo,

1831
01:22:16,586 --> 01:22:18,300
dejen que vuelva a compilar el programa,

1832
01:22:18,300 --> 01:22:20,120
dejen que lo vuelva a ejecutar

1833
01:22:20,120 --> 01:22:21,290
y pierda mi dólar.

1834
01:22:21,290 --> 01:22:25,340
Voy a cambiar... no sé...
a los 55 dígitos posibles.

1835
01:22:25,340 --> 01:22:27,970
Observemos a profundidad
dentro del número.

1836
01:22:27,970 --> 01:22:29,420
./imprecision.

1837
01:22:29,420 --> 01:22:30,955
Interesante.

1838
01:22:30,955 --> 01:22:34,080
Entonces, si alguien más jugara,
apostaría de nuevo el dólar en este punto.

1839
01:22:34,080 --> 01:22:38,264
Y ahora, vemos que 1 dividido entre
10 en realidad no es 0.10000,

1840
01:22:38,264 --> 01:22:42,230
como nuestros maestros de primaria
nos dijeron, esos ceros deberían irse

1841
01:22:42,230 --> 01:22:43,460
al infinito.

1842
01:22:43,460 --> 01:22:44,940
Es impreciso.

1843
01:22:44,940 --> 01:22:46,730
¿Por qué es así?

1844
01:22:46,730 --> 01:22:50,630
¿Por que 1 dividido entre 10, al menos
en mi Mac o en el IDE de CS50,

1845
01:22:50,630 --> 01:22:52,060
no es en realidad 0.1?

1846
01:22:52,060 --> 01:22:55,970

1847
01:22:55,970 --> 01:22:58,130
¿Qué les dice su intuición?

1848
01:22:58,130 --> 01:23:01,970
Bueno, si solo tienen una
cantidad finita de este elemento,

1849
01:23:01,970 --> 01:23:04,660
solo pueden representar
un número finito de números, ¿verdad?

1850
01:23:04,660 --> 01:23:07,730
Si solo tienen 32 o 64 bits, sin embargo,
no importa cuantos bits tengan

1851
01:23:07,730 --> 01:23:10,370
solo podrán permutarlos
en un número finito de maneras.

1852
01:23:10,370 --> 01:23:13,490
Finalmente, se quedarán
sin patrones de ceros y unos.

1853
01:23:13,490 --> 01:23:18,080
Y resulta que 1 dividido por 10,
por lo menos en este equipo,

1854
01:23:18,080 --> 01:23:22,460
no puede representarse con precisión
porque no tenemos un número infinito

1855
01:23:22,460 --> 01:23:26,870
de patrones 0 y 1 para representar los
números reales posibles, llamado

1856
01:23:26,870 --> 01:23:28,166
Valores de punto de flotante.

1857
01:23:28,166 --> 01:23:30,290
Porque, por supuesto,
hay un número infinito de ellos

1858
01:23:30,290 --> 01:23:33,980
y solo una cantidad
finita de memoria.

1859
01:23:33,980 --> 01:23:38,330
Para concluir, y esto tiene
implicaciones en el mundo real,

1860
01:23:38,330 --> 01:23:43,340
si alguna vez
jugaron Lego Star Wars

1861
01:23:43,340 --> 01:23:47,090
habrán notado que el número máximo
de monedas que podían recolectar

1862
01:23:47,090 --> 01:23:49,160
era de 4 mil millones

1863
01:23:49,160 --> 01:23:50,660
y lo redondeaban un poco.

1864
01:23:50,660 --> 01:23:52,640
Técnicamente se podía contar
un poco más de 4 mil millones,

1865
01:23:52,640 --> 01:23:54,920
y probablemente era porque,
¿qué tipo de datos usaba Lego

1866
01:23:54,920 --> 01:23:57,560
para almacenar
el número de monedas?

1867
01:23:57,560 --> 01:23:59,360
Números enteros,
que son de 32 bits.

1868
01:23:59,360 --> 01:24:00,880
Todo estaba bien,

1869
01:24:00,880 --> 01:24:03,380
ya que en realidad
lo anticiparon y pensaron en ello.

1870
01:24:03,380 --> 01:24:05,480
Aquí vemos un Boeing 787,

1871
01:24:05,480 --> 01:24:07,980
o de hecho, aquí
hay una historia divertida.

1872
01:24:07,980 --> 01:24:11,494
Bueno, este es
un Boeing 787 cuya

1873
01:24:11,494 --> 01:24:13,910
documentación asociada a él,
donde decía que el avión debía

1874
01:24:13,910 --> 01:24:17,840
ser reiniciado cada 248 días.

1875
01:24:17,840 --> 01:24:21,680
En especial este avión modelo 787,
que había funcionado continuamente

1876
01:24:21,680 --> 01:24:26,900
durante 248 días, si no se reiniciaba
podía perder toda su corriente eléctrica

1877
01:24:26,900 --> 01:24:30,560
debido a que la computadora
se ponía simultáneamente

1878
01:24:30,560 --> 01:24:31,434
en modo a prueba de fallos.

1879
01:24:31,434 --> 01:24:33,350
Esta condición era
causada por un software contador

1880
01:24:33,350 --> 01:24:36,140
interno en la computadora,
que se desbordaba

1881
01:24:36,140 --> 01:24:39,470
después de recibir 248 días
de corriente continua.

1882
01:24:39,470 --> 01:24:41,750
Así que una
compañía como Boeing

1883
01:24:41,750 --> 01:24:44,900
no sabía que si dejaban un avión
durante el tiempo suficiente

1884
01:24:44,900 --> 01:24:47,870
y solo se utiliza un número
entero o 32 bits, o lo que sea

1885
01:24:47,870 --> 01:24:51,020
esos números podrían, sigilosamente,
ser lo suficientemente grandes como para

1886
01:24:51,020 --> 01:24:55,060
invertirse y causar una catastrófe,
como hacer que el avión se apague

1887
01:24:55,060 --> 01:24:55,930
en este caso.

1888
01:24:55,930 --> 01:24:59,840
Y un poco menos aterrador,
pero no obstante real,

1889
01:24:59,840 --> 01:25:03,050
les contaré un cuento
antes de finalizar,

1890
01:25:03,050 --> 01:25:06,594
y se trata de Civilización,
o de Gandhi en este caso.

1891
01:25:06,594 --> 01:25:08,510
Si llegan a jugar
el juego Civilización

1892
01:25:08,510 --> 01:25:12,290
elijan al personaje de Gandhi, quien era
muy tranquilo, según la definición

1893
01:25:12,290 --> 01:25:14,930
del juego, tenía un nivel de agresividad

1894
01:25:14,930 --> 01:25:17,990
de solo uno, lo cual significa
que era muy inofensivo.

1895
01:25:17,990 --> 01:25:19,940
Pero los autores de
este juego, Civilización,

1896
01:25:19,940 --> 01:25:23,510
solo utilizaron 8 bits, eso significa
que solo pueden contar hasta 255.

1897
01:25:23,510 --> 01:25:26,070
Entonces 255 sería
el máximo de agresividad.

1898
01:25:26,070 --> 01:25:27,990
Así que 1 es nada agresivo.

1899
01:25:27,990 --> 01:25:31,520
Pero hay una característica en el juego,
en la cual, si Gandhi en su civilización

1900
01:25:31,520 --> 01:25:35,450
adoptaba la democracia,
había una línea de código que

1901
01:25:35,450 --> 01:25:38,300
decía que, si en cualquier época
una civilización adopta la democracia,

1902
01:25:38,300 --> 01:25:42,650
su agresividad disminuye por dos,
ya que son personas satisfechas.

1903
01:25:42,650 --> 01:25:48,860
Desafortunadamente, si sus niveles de
agresividad comienzan en 1 y le restan 2,

1904
01:25:48,860 --> 01:25:54,830
se puede desbordar, o desbordarse
inversamente, como ocurre en 1 menos 2,

1905
01:25:54,830 --> 01:25:56,480
que daría un 1 negativo.

1906
01:25:56,480 --> 01:25:59,030
Y esto, de hecho, sería 255.

1907
01:25:59,030 --> 01:26:02,840
Así que nos daría la
cifra absurdamente alta de 255

1908
01:26:02,840 --> 01:26:07,040
y haría que Gandhi tuviera el nivel
más agresivo que existe en Civilización.

1909
01:26:07,040 --> 01:26:09,590
Así que aquí podemos ver
decisiones de diseño del mundo real.

1910
01:26:09,590 --> 01:26:13,640
Y lo que haremos en la próxima
lección del viernes, y posteriormente,

1911
01:26:13,640 --> 01:26:16,750
es explorar estas cuestiones, iniciaremos
resolviendo problemas sobre ellas.

1912
01:26:16,750 --> 01:26:18,710
Mientras tanto, la serie
de problemas uno ya está en línea.

1913
01:26:18,710 --> 01:26:20,570
La reunión de orientación
es hoy y mañana.

1914
01:26:20,570 --> 01:26:22,653
Pueden quedarse
si tienen dudas o preguntas.

1915
01:26:22,653 --> 01:26:24,970
Y nos vemos el siguiente viernes.