~herlock_sholmes/PensamientoComputacional

a0f2c5d8c0edd88cad1efd6b6e023fa6b7896a5a — Camilo Meza Gaete 10 months ago 8a6e405
0025: Se comienza con los juegos

Para que los estudiantes del electivo de programación estudien mientras juegan.
M .gitignore => .gitignore +8 -0
@@ 7,3 7,11 @@ tmp/
# Ignora los archivos compilados de clisp

*.fasl

# Ignora los archivos de LaTeX intermediarios

*.aux
*.out
*.pdf
*.synctex.gz
*.toc

A EjemplosRacket/Juegos/AdivinaElNumero/adivina.rkt => EjemplosRacket/Juegos/AdivinaElNumero/adivina.rkt +225 -0
@@ 0,0 1,225 @@
#lang racket

#|
   Juego de adivina el número, jugado en un REPL de Racket
   ---------------------------------------------------

   Eliges un número. El programa adivina el número
   haciendo preguntas. Las repuestas son "muy pequeño"
   "muy grande" y "lo adivinaste".


   ¿Cómo jugar?
   ----
   Compila el programa en Emacs, o desde la zona de definiciones
   de Dr. Racket Clicka Run. Elige un número entre <n> y <m>.
   Evalúa en la REPL
       (start <n> <m>)
   El programa responderá con un número.
   Usa
       (bigger)
   o
       (smaller)
   para expresar lo que piensas de sus intentos.
|#

;
;
;
;                          ;
;                          ;
;  ;;;   ;;;
;   ;;   ;;
;   ; ; ; ;     ;;;;     ;;;      ;; ;;;
;   ; ; ; ;    ;    ;      ;       ;;   ;
;   ; ; ; ;         ;      ;       ;    ;
;   ;  ;  ;    ;;;;;;      ;       ;    ;
;   ;     ;   ;     ;      ;       ;    ;
;   ;     ;   ;    ;;      ;       ;    ;
;  ;;;   ;;;   ;;;; ;;  ;;;;;;;   ;;;  ;;;
;
;
;
;

;; Ejemplo:
;; > (start 0 100)       ; [0,100]
;; 50
;; > (bigger)            ; [51,100]
;; 75
;; > (bigger)            ; [76,100]
;; 88
;; > (smaller)           ; [76,87]
;; 82

;; Número Número -> Número
;; Inicia un nuevo juego en [n,m] y realiza un intento.
;; > (start 0 100)
;; 50

(define (start n m)
  (set! lower (min n m))
  (set! upper (max n m))
  (guess))

;; Límites inferiores y superiores en el número
(define lower 1)
(define upper 100)

;; -> Número Número
;; Adivina al punto medio entre los límites inferiores y superiores.
;; > (begin (start 0 100) (guess))
;; 50

(define (guess)
  (quotient (+ lower upper) 2))

;; -> Número
;; Disminuye el límite superior e intenta de nuevo.
;; > (begin (start 0 100) (smaller))
;; 24

(define (smaller)
  (set! upper (max lower (sub1 (guess))))
  (guess))

;; -> Número
;; Aumenta el límite inferior e intenta de nuevo.
;; > (begin (start 0 100) (bigger))
;; 75

(define (bigger)
  (set! lower (min upper (add1 (guess))))
  (guess))

;
;
;
;
;
;   ;;;;;;;                        ;
;   ;  ;  ;                        ;
;   ;  ;  ;     ;;;      ;;;; ;  ;;;;;;;     ;;;; ;
;   ;  ;  ;    ;   ;    ;    ;;    ;        ;    ;;
;      ;      ;     ;   ;          ;        ;
;      ;      ;;;;;;;    ;;;;;     ;         ;;;;;
;      ;      ;               ;    ;              ;
;      ;       ;    ;   ;     ;    ;    ;   ;     ;
;    ;;;;;      ;;;;    ;;;;;;      ;;;;    ;;;;;;
;
;
;
;


(module+ test

  (require rackunit rackunit/text-ui)

  ;; intentos básicos

  (check-equal? (guess) 50)

  (check-equal? (start 0 100) 50)

  (check-equal? (begin (start 0 100) lower) 0)
  (check-equal? (begin (start 0 100) upper) 100)
  (check-equal? (begin (start 0 100) (smaller)) 24)
  (check-equal? (begin (start 0 000) (smaller)) 0)
  (check-equal? (begin (start 0 100) (smaller) lower) 0)
  (check-equal? (begin (start 0 100) (smaller) upper) 49)
  (check-equal? (begin (start 0 100) (bigger)) 75)
  (check-equal? (begin (start 0 000) (bigger)) 0)

  ;; probando una secuencia de interaciones con los estados intermediarios esperados

  (test-begin (start 0 100)
              (bigger)
              (check-equal? lower 51)
              (check-equal? upper 100)
              (bigger)
              (check-equal? lower 76)
              (check-equal? upper 100)
              (smaller)
              (check-equal? lower 76)
              (check-equal? upper 87))

  ;; haciendo lo mismo para números negativos

  (check-equal? (start -100 0) -50)

  (check-equal? (begin (start -100 0) lower) -100)
  (check-equal? (begin (start -100 0) upper) 0)
  (check-equal? (begin (start -100 0) (smaller)) -75)
  (check-equal? (begin (start -100 0) (smaller)) -75)
  (check-equal? (begin (start -100 0) (smaller) lower) -100)
  (check-equal? (begin (start -100 0) (smaller) upper) -51)
  (check-equal? (begin (start -100 0) (bigger)) -24)
  (check-equal? (begin (start -100 0) (bigger)) -24)

  (test-begin (start -100 0)
              (bigger)
              (check-equal? lower -49)
              (check-equal? upper 0)
              (bigger)
              (check-equal? lower -23)
              (check-equal? upper 0)
              (smaller)
              (check-equal? lower -23)
              (check-equal? upper -12))


  ;; ---------------------------------------------------------------------------
  ;; probando propiedades azarosas de nuestras funciones

  ;; Propiedad:
  ;; Para todos los juegos comenzando en [n,m] después de cualquier cantidad de movimientos,
  ;; lower <= upper

  (define (prop:ordered n m i)
    (check-true
     (begin (start n m)
            (random-moves i)
            (<= lower upper))))

  ;; Propiedad:
  ;; Para todos los juegos comenzando en [n,m], para cualquier cantidad de movimientos,
  ;; lower crece, upper decrece, o son iguales.

  (define (prop:monotonic n m i)
    (check-true
     (begin (start n m)
            (for/and ([i (in-range i)])
              (define l lower)
              (define u upper)
              (random-move)
              (or (and (< l lower) (= u upper))
                  (and (= l lower) (> u upper))
                  (and (= l lower) (= u upper)))))))

  ;; Número -> Vacío
  ;; Moverse azarosamente n veces.

  (define (random-moves i)
    (unless (zero? i)
      (random-move)
      (random-moves (sub1 i))))

  ;; -> Vacío
  ;; Moverse azarosamente una vez.

  (define (random-move)
    (if (zero? (random 2))
        (smaller)
        (bigger)))

  ;; pruebas de propiedades

  (for ([i (in-range 1000)])
    (prop:ordered (random 1000) (random 1000) (random 100))
    (prop:monotonic (random 1000) (random 1000) (random 100)))

  ;; reinciar los límites a los por defecto
  (start 1 100)

  "all tests run")

M EjemplosRacket/SICP/Capitulo1/Ejercicio1.rkt => EjemplosRacket/SICP/Capitulo1/Ejercicio1.rkt +2 -1
@@ 18,7 18,8 @@

(define b (+ a 1)) ; le asgina el valor de a+1 al símbolo b.

(+ a b (* a b)) ; evalúa al valor de la suma de a, b, y el producto a*b.
(+ a b (* a b)) ; evalúa al valor de la suma de a, b, y el producto a*b,
                ; lo que sería 19 siguiendo las definiciones previas.

(= a b) ; evalúa a #f porque b tiene un valor de a+1, lo que no sería igual.


A Presentaciones/MalditosParentesis/.auctex-auto/Notas.el => Presentaciones/MalditosParentesis/.auctex-auto/Notas.el +41 -0
@@ 0,0 1,41 @@
(TeX-add-style-hook
 "Notas"
 (lambda ()
   (TeX-add-to-alist 'LaTeX-provided-class-options
                     '(("article" "11pt")))
   (TeX-add-to-alist 'LaTeX-provided-package-options
                     '(("inputenc" "utf8") ("fontenc" "T1") ("ulem" "normalem") ("geometry" "margin=0.5in")))
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "href")
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "hyperref")
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "hyperimage")
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "hyperbaseurl")
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "nolinkurl")
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "url")
   (add-to-list 'LaTeX-verbatim-macros-with-braces-local "path")
   (add-to-list 'LaTeX-verbatim-macros-with-delims-local "path")
   (TeX-run-style-hooks
    "latex2e"
    "article"
    "art11"
    "inputenc"
    "fontenc"
    "graphicx"
    "longtable"
    "wrapfig"
    "rotating"
    "ulem"
    "amsmath"
    "amssymb"
    "capt-of"
    "hyperref"
    "geometry")
   (LaTeX-add-labels
    "sec:org0134523"
    "sec:org2403513"
    "sec:org76135ce"
    "sec:orga17b0a5"
    "sec:org9511166")
   (LaTeX-add-bibliographies
    "citas"))
 :latex)


A Presentaciones/MalditosParentesis/.auctex-auto/citas.el => Presentaciones/MalditosParentesis/.auctex-auto/citas.el +11 -0
@@ 0,0 1,11 @@
(TeX-add-style-hook
 "citas"
 (lambda ()
   (LaTeX-add-bibitems
    "twobit_lisp_2018"
    "abelson_structure_2002"
    "felleisen_realm_2013"
    "noauthor_eternal_nodate"
    "findler_slideshow:_2006"))
 :bibtex)


A Presentaciones/MalditosParentesis/Notas.bbl => Presentaciones/MalditosParentesis/Notas.bbl +25 -0
@@ 0,0 1,25 @@
\begin{thebibliography}{1}

\bibitem{noauthor_eternal_nodate}
Eternal {Flame} - {GNU} {Project} - {Free} {Software} {Foundation}.

\bibitem{twobit_lisp_2018}
How {Lisp} {Became} {God}'s {Own} {Programming} {Language}.

\bibitem{abelson_structure_2002}
Harold Abelson, Gerald~Jay Sussman, and Julie Sussman.
\newblock {\em Structure and interpretation of computer programs}.
\newblock Electrical engineering and computer science series. MIT Press [u.a.],
  Cambridge, Mass., 2. ed., 7. [pr.] edition, 2002.

\bibitem{felleisen_realm_2013}
Matthias Felleisen.
\newblock {\em Realm of {Racket}: learn to program, one game at a time!}
\newblock No Starch Press, San Francisco, 2013.

\bibitem{findler_slideshow:_2006}
Robert~Bruce Findler and Matthew Flatt.
\newblock Slideshow: functional presentations.
\newblock {\em Journal of Functional Programming}, 16(4-5):583--619, July 2006.

\end{thebibliography}

A Presentaciones/MalditosParentesis/Notas.blg => Presentaciones/MalditosParentesis/Notas.blg +49 -0
@@ 0,0 1,49 @@
This is BibTeX, Version 0.99d (TeX Live 2019)
Capacity: max_strings=100000, hash_size=100000, hash_prime=85009
The top-level auxiliary file: Notas.aux
The style file: plain.bst
Database file #1: citas.bib
Warning--to sort, need author or key in twobit_lisp_2018
Warning--to sort, need author or key in noauthor_eternal_nodate
You've used 5 entries,
            2118 wiz_defined-function locations,
            523 strings with 4657 characters,
and the built_in function-call counts, 1176 in all, are:
= -- 110
> -- 40
< -- 0
+ -- 17
- -- 12
* -- 70
:= -- 186
add.period$ -- 12
call.type$ -- 5
change.case$ -- 20
chr.to.int$ -- 0
cite$ -- 7
duplicate$ -- 49
empty$ -- 118
format.name$ -- 12
if$ -- 255
int.to.chr$ -- 0
int.to.str$ -- 5
missing$ -- 5
newline$ -- 24
num.names$ -- 6
pop$ -- 32
preamble$ -- 1
purify$ -- 16
quote$ -- 0
skip$ -- 40
stack$ -- 0
substring$ -- 50
swap$ -- 5
text.length$ -- 0
text.prefix$ -- 0
top$ -- 0
type$ -- 16
warning$ -- 2
while$ -- 8
width$ -- 6
write$ -- 47
(There were 2 warnings)

A Presentaciones/MalditosParentesis/Notas.org => Presentaciones/MalditosParentesis/Notas.org +41 -0
@@ 0,0 1,41 @@
#+title: Notas "Malditos paréntesis"
#+author: Camilo Meza Gaete
#+bibliography: citas
#+latex_header_extra: \bibliographystyle{plain}
#+latex_header_extra: \twocolumn
#+latex_header_extra: \usepackage[margin=0.5in]{geometry}
#+options: toc:nil num:nil

* Historia de LISP


* Mística y narrativa

Las grandes historias tienen la capacidad de provocar emociones en consonancia
con los temas que tratan. Un ejemplo de esto son las narraciones con realismo
mágico (corriente literaria que está muy presente en la cultura
latinoamericana).

Este trastoque de fantasía y realidad podría ser una bendición al momento de
decidir contar una historia, revestirla de un misterio original que permita a la
gente acceder a ella con maravilla y curiosidad.

Cuando estamos enseñando a adolescentes podríamos usar estos misterios y
curiosidades con fines pedagógicos: Ya no son infantes,y debemos dejar de pensar
en ellos como no-adultos. Tomar esta alternativa puede facilitar el acceso a
reflexiones más profundas o descubrir pasiones que de otro modo no podrían
porque les resulten ajenas o complejas.

LISP ya goza de esta mística que lo envuelve\cite{twobit_lisp_2018}, esto lo
convierte en un gran candidato para la labor de ser el Merlín en la búsqueda de
cada estudiante dentro del gran mundo que es el pensamiento computacional.


* Racket y sus lenguajes

* Palabras finales

\newpage
* Bibliografía
\nocite{*}
\bibliography{citas}

A Presentaciones/MalditosParentesis/Notas.tex => Presentaciones/MalditosParentesis/Notas.tex +53 -0
@@ 0,0 1,53 @@
% Created 2021-11-10 Wed 17:59
% Intended LaTeX compiler: pdflatex
\documentclass[11pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{graphicx}
\usepackage{longtable}
\usepackage{wrapfig}
\usepackage{rotating}
\usepackage[normalem]{ulem}
\usepackage{amsmath}
\usepackage{amssymb}
\usepackage{capt-of}
\usepackage{hyperref}
\bibliographystyle{plain}
\twocolumn
\usepackage[margin=0.5in]{geometry}
\hypersetup{citecolor=1 1 1}
\author{Camilo Meza Gaete}
\date{\today}
\title{Notas ``Malditos paréntesis''}
\hypersetup{
 pdfauthor={Camilo Meza Gaete},
 pdftitle={Notas ``Malditos paréntesis''},
 pdfkeywords={},
 pdfsubject={},
 pdfcreator={Emacs 27.2 (Org mode 9.5)}, 
 pdflang={English}}
\begin{document}

\maketitle

\section*{Historia de LISP}
\label{sec:org6d23667}

Escribir una cita o referencia\cite{felleisen_realm_2013}


\section*{Mística y narrativa}
\label{sec:org91b2436}

\section*{Racket y sus lenguajes}
\label{sec:orgdecb5d1}

\section*{Palabras finales}
\label{sec:org1af11df}

\newpage
\section*{Bibliografía}
\label{sec:orgb861c01}
\nocite{*}
\bibliography{citas}
\end{document}

M Presentaciones/MalditosParentesis/Presentacion.rkt => Presentaciones/MalditosParentesis/Presentacion.rkt +12 -4
@@ 1,16 1,24 @@
#lang slideshow/widescreen

;;; Ejemplos de construcción simple de diapositivas
;;; Presentación del (it Encuentro de Software Libre)

(slide
 #:title "Malditos paréntesis"
 (t "Primero esto")
 (t "Segundo esto")
 (t "tercero esto"))
 (titlet "o de ¿por qué es importante enseñar LISP en secundaria")
 (bitmap "./img/racket.png"))

;; Items en una diapo

(slide
 #:title "The eternal flame - Julia Ecklar & Bob Kanefsky"
 (para (it " And God wrote in Lisp code every creature great and small.")
       (it "Don't search the disk drive for man.c, when the listing's on the wall.")
       (it "And when I watch the lightning burn unbelievers to a crisp,")
       (it "I know God had six days to work. So he wrote it all in Lisp.")
       (it "Yes, God had a deadline. So he wrote it all in Lisp.")))


(slide
 #:title "Ejemplo intemizado"
 (item "Este es un conjunto de"
       "Frases separados por item" (bt "y esto está enfatizado."))

A Presentaciones/MalditosParentesis/citas.bib => Presentaciones/MalditosParentesis/citas.bib +54 -0
@@ 0,0 1,54 @@

@misc{twobit_lisp_2018,
	title = {How {Lisp} {Became} {God}'s {Own} {Programming} {Language}},
	url = {https://twobithistory.org/2018/10/14/lisp.html},
	abstract = {A look at the fascinating history behind the one programming language with magical powers.},
	urldate = {2021-11-10},
}

@book{abelson_structure_2002,
	address = {Cambridge, Mass.},
	edition = {2. ed., 7. [pr.]},
	series = {Electrical engineering and computer science series},
	title = {Structure and interpretation of computer programs},
	isbn = {9780262510875 9780262011532 9780070004849},
	language = {eng},
	publisher = {MIT Press [u.a.]},
	author = {Abelson, Harold and Sussman, Gerald Jay and Sussman, Julie},
	year = 2002,
}

@book{felleisen_realm_2013,
	address = {San Francisco},
	title = {Realm of {Racket}: learn to program, one game at a time!},
	isbn = 9781593274917,
	shorttitle = {Realm of {Racket}},
	publisher = {No Starch Press},
	author = {Felleisen, Matthias},
	year = 2013,
	keywords = {Racket (Computer program language), LISP (Computer program language), Computer programming},
}

@misc{noauthor_eternal_nodate,
	title = {Eternal {Flame} - {GNU} {Project} - {Free} {Software} {Foundation}},
	url = {https://www.gnu.org/fun/jokes/eternal-flame.en.html},
	urldate = {2021-11-10},
}

@article{findler_slideshow:_2006,
	title = {Slideshow: functional presentations},
	volume = {16},
	issn = {0956-7968, 1469-7653},
	shorttitle = {Slideshow},
	url = {https://www.cambridge.org/core/product/identifier/S0956796806006010/type/journal_article},
	doi = {10.1017/S0956796806006010},
	abstract = {Among systems for creating slide presentations, the dominant ones offer essentially no abstraction capability. Slideshow represents our effort over the last several years to build an abstraction-friendly slide system with PLT Scheme. We show how functional programming is well suited to the task of slide creation, we report on the programming contructs that we have developed for slides, and we describe our solutions to practical problems in rendering slides. We also describe experimental extensions to DrScheme that support a mixture of programmatic and WYSIWYG slide creation.},
	language = {en},
	number = {4-5},
	urldate = {2021-11-10},
	journal = {Journal of Functional Programming},
	author = {Findler, Robert Bruce and Flatt, Matthew},
	month = jul,
	year = {2006},
	pages = {583--619},
}

A Presentaciones/MalditosParentesis/img/racket.png => Presentaciones/MalditosParentesis/img/racket.png +0 -0
A Presentaciones/MalditosParentesis/img/sicp.jpg => Presentaciones/MalditosParentesis/img/sicp.jpg +0 -0