/
aa_get_started_es.Rmd
175 lines (146 loc) · 6.31 KB
/
aa_get_started_es.Rmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
---
title: "Primeros pasos con la robot Karel"
output: rmarkdown::html_vignette
description: >
Quién es Karel y para qué sirve este paquete
vignette: >
%\VignetteIndexEntry{Primeros pasos con la robot Karel}
%\VignetteEngine{knitr::rmarkdown}
%\VignetteEncoding{UTF-8}
---
```{r, include = FALSE}
knitr::opts_chunk$set(
collapse = TRUE,
comment = "",
prompt = TRUE,
fig.align = "center"
)
```
## ¿Quién es Karel?
`karel` es un paquete de R creado
con el propósito de brindar un entorno que posibilite la enseñanza de
principios de la programación en una forma dinámica e interactiva, para
estudiantes sin experiencia previa que estén cursando el nivel
secundario o los primeros años de su formación de grado. *Karel* es
una robot que vive y camina por ciertos *mundos*, en los cuales
puede realizar determinadas acciones si se lo pedimos, mientras
aprendemos a programar en R.
La robot Karel acompaña en la enseñanza de conceptos fundamentales de la
programación, por ejemplo, el de procesador (Karel), ambiente (su mundo),
objetos (llamados *cosos*) y acciones (las actividades que puede realizar).
Además, como se puede observar en los ejemplos de los tutoriales presentes en
esta página, junto con Karel es posible instruir sobre el concepto de la
descomposición algorítmica: en numerosas oportunidades la robot debe cumplir
objetivos cuya resolución requiere descomponer el problema en partes más
pequeñas, para cada una de las cuales los estudiantes deben programar una
función en R. También facilita la ejemplificación del uso de estructuras de
control de código secuenciales, condicionales (`if () {} else {}`) e iterativas
(`for () {}`, `while () {}`).
El primer paso para programar con Karel es *generar un mundo* en el
cual ella pueda andar, a través de la instrucción
`generar_mundo()`, aclarando entre los paréntesis el nombre del
mundo que queremos usar. El paquete trae incorporados unos cuantos pero
los usuarios pueden optar por crear otros nuevos.
Todos los mundos de Karel son rectangulares, compuestos por calles que los
recorren horizontalmente (filas) y avenidas verticales (columnas). Karel siempre
se encuentra en la intersección entre una calle y una avenida (celda), mirando
hacia una de las cuatro direcciones posibles: este, norte, oeste o sur. Los
bordes negros representan paredes que Karel no puede atravesar, solo puede
rodearlas. Además, en algunas celdas hay uno o varios *cosos*. Karel puede
recorrer el mundo poniendo y juntando *cosos* por ahí; si los junta los guarda
en su mochila y lleva un registro de cuántos tiene. Finalmente, Karel solo puede
realizar estas actividades: `avanzar()`, `girar_izquierda()`, `juntar_coso()` y
`poner_coso()`. Claro, agrupando ingeniosamente estas acciones básicas se pueden
crear otras nuevas, por ejemplo, crear una función `girar_derecha()` que
produzca tal efecto, haciendo girar a Karel tres veces a la izquierda. Por otro
lado, Karel es capaz de evaluar ciertas características de su entorno a través
de funciones que arrojan un valor lógico `TRUE` o `FALSE`, por ejemplo:
`frente_abierto()`, `hay_cosos()` o `mira_al_sur()`, de manera que podemos
condicionar las acciones que Karel realiza a la verificación de ciertos aspectos
sobre su posición y su mundo. Una vez que se ejecuta el código con todas las
acciones que Karel debe realizar, se debe correr la función
`ejecutar_acciones()` y se puede ver el resultado en una animación creada con
los paquetes `ggplot` y `gganimate`.
Con el objetivo de sortear algunas de las barreras idiomáticas que
pueden hacer más desafiante poder dar los primeros pasos en el
aprendizaje de programación, el paquete `karel` se diseñó de
forma completamente bilingüe: todas las funciones tienen una versión en
español y en inglés (por ejemplo,`girar_izquierda()` y
`turn_left()`), así como también las páginas del manual de ayuda y algunas
del sitio web están escritos en ambos idiomas.
La idea para la implementación de este paquete se basa en *Karel
the Robot*, un lenguaje de programación creado con fines educativos por
el Dr. R. E. Pattis de la Universidad de Stanford (California, EEUU),
quien también escribió el libro *Karel the Robot: A Gentle
Introduction to the Art of Programming*, en 1981. Su nombre es un
homenaje a Karel Capek, el escritor sueco que inventó la palabra robot
en su obra de ciencia ficción *R.U.R. (Rossum's Universal Robots)*.
Su sintaxis se basaba en Pascal, pero a lo largo de las décadas esta
estrategia de enseñanza fue implementada en distintos lenguajes como
Java, C++, Ruby y Python. El paquete aquí presentado es la primera
implementación de Karel para R. Algunos de los ejemplos incluidos en las
viñetas son adaptaciones de aquellos publicados por Eric Roberts en su
material *Karel the robot learns Java* (2005).
## Instalación
Podés instalar `karel` desde [CRAN](https://CRAN.R-project.org/package=karel):
``` r
install.packages("karel")
```
También podés instalar la versión en desarrollo desde
[GitHub](https://github.com/mpru/karel):
``` r
# install.packages("devtools")
devtools::install_github("mpru/karel")
```
## Ejemplos
¿Podés escribir un programa para que Karel coloque *cosos* en los vértices del
*rombo* en en el cual está encerrada?
```{r, echo=F, out.width="60%"}
knitr::include_graphics("problema1.png")
```
¿Algo así, tal vez?
```{r, eval = FALSE}
# Cargar el paquete y los superpoderes de Karel
library(karel)
cargar_super_karel()
# Crear funciones auxiliares
recorrer_diagonal <- function() {
while (frente_abierto()) {
avanzar()
girar_izquierda()
avanzar()
girar_derecha()
}
}
# Implementar el problema
generar_mundo("mundo019")
for (i in 1:4) {
recorrer_diagonal()
poner_coso()
girar_derecha()
}
ejecutar_acciones()
```
```{r, echo=F, out.width="50%"}
if (knitr::is_html_output()) knitr::include_graphics("33.gif")
```
Ahora Karel está en un laberinto. ¿Podemos hacerla llegar hasta el final?
```{r, echo=F, out.width="50%"}
knitr::include_graphics("29.png")
```
Sí, con este código:
```{r, eval=F}
generar_mundo("mundo009")
while (no_hay_cosos()) {
girar_derecha()
while (frente_cerrado()) {
girar_izquierda()
}
avanzar()
}
ejecutar_acciones()
```
```{r, echo=F, out.width="50%"}
if (knitr::is_html_output()) knitr::include_graphics("30.gif")
```
Podés ver más detalles sobre estos ejemplos y otros en la sección de tutoriales.