Pensamiento computacional, entorno y control de versiones

Cómo usar esta guía

El curso es aula invertida: el libro es la primera fuente, la clase es laboratorio. Usa esta página en cuatro momentos:

Cada tema sigue el mismo ciclo. Acostúmbrate a él: es la forma en la que se resuelve un problema real y la forma en que te van a preguntar en la defensa.

• Pregunta
• →
• Exploración
• →
• Implementación
• →
• Resultado
• →
• Interpretación
• →
• Verificación

Qué puedes usar esta semana

Regla de progresión: en esta guía nunca se usa algo que el curso enseña en una semana posterior. Si lo ves antes, está marcado como adelanto opcional.

Lecturas de preparación

Marca cada lectura cuando la termines. Tu avance se guarda en este navegador.

• [BOU] Cap. 1 “Algorithmic Thinking and Flowcharts”. Enfócate en: qué hace a un algoritmo correcto, los símbolos del diagrama de flujo y cómo se pasa de un enunciado a pasos.
• [PCC] Cap. 1 “Getting Started”. Enfócate en: instalar Python, configurar VS Code, ejecutar hello_world.py desde el editor y desde la terminal, y qué hacer si no corre.
• [PCC] Apéndice D “Using Git for Version Control”. Enfócate en: el flujo add → commit, revisar el historial y volver a un estado anterior.
• [GIT] Cap. 1 “Inicio - Sobre el control de versiones”. Es de acceso libre en español: git-scm.com/book/es/v2. Enfócate en: local vs. centralizado vs. distribuido, y los tres estados de un archivo.

Reading checkpoint

Responde después de leer y sin volver al libro. Cada respuesta muestra por qué es correcta o no.

• Respondí el checkpoint y entiendo por qué fallé las que fallé.

El ciclo de vida del software

Un programa no empieza en el teclado. Empieza en una necesidad del negocio y termina (si termina) cuando nadie lo usa. Las fases básicas:

Algoritmos y diagramas de flujo

Un algoritmo es una secuencia finita de pasos precisos que transforma unas entradas en unas salidas. Tres pruebas rápidas para saber si lo que escribiste es un algoritmo:

1. Precisión: dos personas distintas que lo sigan obtienen lo mismo.
2. Finitud: termina siempre, para cualquier entrada válida.
3. Entradas y salidas definidas: sabes qué datos necesita y qué entrega.

Caso: el total de una factura en la Distribuidora La Ceiba

Pregunta

La distribuidora vende al por mayor. Regla de negocio: si el subtotal de la compra es de $50 o más, se descuenta el 10 %; luego se cobra el IVA del 13 % sobre el monto con descuento. ¿Cuánto paga el cliente?

Exploración

Antes de escribir nada, identifica:

• Entradas: precio unitario, cantidad.
• Salida: total a pagar.
• Decisión: ¿el subtotal llega a $50?
• Orden importa: primero descuento, luego IVA. Si lo haces al revés, el cliente paga IVA sobre dinero que no pagó.
• Frontera: “$50 o más” incluye el 50 exacto. Es un caso borde.

Implementación (pseudocódigo)

INICIO
  LEER precio_unitario, cantidad
  subtotal ← precio_unitario × cantidad
  SI subtotal ≥ 50 ENTONCES
      descuento ← subtotal × 0.10
  SINO
      descuento ← 0
  FIN SI
  base  ← subtotal − descuento
  iva   ← base × 0.13
  total ← base + iva
  MOSTRAR total
FIN

Resultado

Con precio $12.50 y cantidad 4: subtotal $50.00 → descuento $5.00 → base $45.00 → IVA $5.85 → total $50.85.

Interpretación

El cliente que compra justo $50 paga $50.85, pero uno que compra $49 paga $55.37 ($49 × 1.13). ¡Comprar un poco más le sale más barato! Eso no es un error del algoritmo: es una consecuencia de la regla de negocio. Un buen analista la detecta y se la comunica al gerente.

Verificación — ¿cómo sé que es correcto?

• Recórrelo a mano con al menos un caso de cada rama (sí / no) y el caso frontera ($50 exacto). Eso es una tabla de traza.
• Compara contra una calculadora o una hoja de cálculo.
• Pregúntate: ¿el total es siempre mayor que la base? (Debe serlo, porque el IVA es positivo.)

Entorno y terminal

La terminal es una forma de darle órdenes a la computadora escribiendo. Vas a usarla para ejecutar Python y para Git. Los comandos mínimos:

Tu primer programa (PCC cap. 1). Créalo en VS Code, guárdalo como hola.py y ejecútalo desde la terminal integrada (Ctrl+ñ o menú Terminal → New Terminal):

# Mi primer programa en Python
print("Hola, Distribuidora La Ceiba")
print("Sistema de facturación v0.1")

Hola, Distribuidora La Ceiba
Sistema de facturación v0.1

• Ejecuté hola.py desde VS Code y desde la terminal.

Git y GitHub

Caso: cuatro personas, un mismo sistema

Pregunta

Tu equipo de cuatro va a construir el proyecto integrador durante 11 semanas. ¿Cómo trabajan sin pisarse los cambios, sin mandarse archivos final_v3_ahora_si.py por WhatsApp y demostrando quién hizo qué?

Exploración: los tres lugares de Git

Lugar	Qué hay ahí	Analogía contable
Directorio de trabajo	Tus archivos tal como los editas.	El borrador en tu escritorio.
Área de preparación (staging)	Los cambios que irán en el próximo commit.	Los documentos que metes al sobre para archivar.
Repositorio (.git)	El historial de commits, cada uno con autor, fecha y mensaje.	El libro mayor: cada asiento queda registrado y no se borra.

Por eso un archivo puede estar: sin seguimiento (Git no lo conoce), modificado, preparado o confirmado.

Implementación: configuración inicial (una sola vez por computadora)

git config --global user.name "Tu Nombre Apellido"
git config --global user.email "tu_correo@esen.edu.sv"
git config --global init.defaultBranch main
git config --list          # para comprobar

El correo debe ser el mismo de tu cuenta de GitHub; así tus commits aparecen a tu nombre (y eso cuenta en la rúbrica).

Flujo diario:

mkdir la-ceiba && cd la-ceiba
git init                           # crea el repositorio (.git)
git status                         # ¿qué cambió? úsalo TODO el tiempo
git add README.md                  # prepara un archivo
git add .                          # prepara todo lo que cambió (revisa antes con status)
git commit -m "Agrega ficha técnica del proyecto"
git log --oneline                  # historial resumido

Ramas: una rama por tarea; main siempre debe funcionar.

git branch feature/ficha-tecnica   # crea la rama
git switch feature/ficha-tecnica   # cámbiate a ella (en versiones viejas: git checkout)
# ... editas, add, commit ...
git switch main                    # vuelves a main
git merge feature/ficha-tecnica    # integras el trabajo
git branch -d feature/ficha-tecnica  # borra la rama ya integrada

GitHub (repositorio remoto):

git remote add origin git@github.com:usuario/la-ceiba.git   # con SSH
git push -u origin main            # la primera vez; después basta con: git push
git pull                           # trae lo que subieron tus compañeros
git clone git@github.com:usuario/la-ceiba.git   # tus compañeros, para obtener copia

Autenticación: SSH o token

GitHub ya no acepta tu contraseña para push. Tienes dos opciones:

• SSH (recomendada en tu computadora): generas un par de llaves, subes la pública a GitHub → Settings → SSH and GPG keys.

  ssh-keygen -t ed25519 -C "tu_correo@esen.edu.sv"
  # muestra la llave pública para copiarla a GitHub:
  cat ~/.ssh/id_ed25519.pub
  ssh -T git@github.com              # prueba: debe saludarte por tu usuario

• Token de acceso personal (HTTPS): útil en computadoras del laboratorio. Lo creas en Settings → Developer settings → Personal access tokens y lo pegas cuando Git pida contraseña. Trátalo como una contraseña: nunca lo subas al repositorio.

Resultado

git log --oneline muestra algo así (los códigos cambian en tu máquina):

3f2a9c1 (HEAD -> main) Integra ficha técnica
8b41e07 Agrega .gitignore para Python
c05d2aa Crea README inicial

Interpretación

Cada línea es un punto al que puedes volver. El historial es evidencia: la rúbrica del proyecto revisa que los commits estén distribuidos entre los cuatro y a lo largo de las 11 semanas. Un solo commit gigante la noche antes se califica como deficiente.

Verificación — ¿cómo sé que salió bien?

• git status dice “nothing to commit, working tree clean”.
• git log --oneline muestra tu commit con tu mensaje.
• En GitHub, el commit aparece con tu foto/usuario (si no, revisa user.email).

• Configuré user.name y user.email.
• Creé un repositorio, hice al menos 3 commits y lo subí a GitHub.
• Creé una rama, hice un commit en ella y la integré a main con merge.

Tablas de traza

Una traza es ejecutar el algoritmo tú, paso a paso, anotando el valor de cada variable. Llena las celdas, pulsa Comprobar y solo al final mira la solución. Usa punto decimal (5.85).

Traza 1 · Factura con descuento

Usa el pseudocódigo de factura.pseudo. En “¿≥ 50?” escribe sí o no.

Traza 2 · El estado de un archivo en Git

Después de cada comando, ¿en qué estado queda README.md? Opciones: sin seguimiento, modificado, preparado, confirmado, o combinaciones como preparado y modificado.

• Completé la traza 1 sin ver la solución.
• Completé la traza 2 y puedo explicar los pasos 6 y 7.

Ejercicios

Intenta cada uno en papel primero. Abre la pista solo si llevas 10 minutos atascado; abre la solución solo después de tener tu versión.

INICIO
  LEER minutos, tiene_sello
  horas ← techo(minutos / 60)
  cobro ← 1.00 + (horas − 1) × 0.75
  SI cobro > 6.00 ENTONCES
      cobro ← 6.00
  FIN SI
  SI tiene_sello ENTONCES
      cobro ← cobro − 1.00
  FIN SI
  SI cobro < 0 ENTONCES
      cobro ← 0
  FIN SI
  MOSTRAR cobro
FIN

LEER subtotal, compras_90_dias
tasa ← 0
SI compras_90_dias ≥ 5 ENTONCES tasa ← tasa + 0.05
SI subtotal ≥ 100      ENTONCES tasa ← tasa + 0.05
base  ← subtotal × (1 − tasa)
total ← base × 1.13
MOSTRAR total

mkdir ceiba
cd ceiba
git init
# crea README.md en VS Code
git add README.md
git commit -m "Crea README inicial"
git branch feature/ficha-tecnica
git switch feature/ficha-tecnica
# crea ficha.md en VS Code
git add ficha.md
git commit -m "Agrega ficha técnica del proyecto"
git switch main
git merge feature/ficha-tecnica
git remote add origin git@github.com:usuario/ceiba.git
git push -u origin main

# Ticket de caja: solo texto por ahora (las variables llegan en la semana 2)
print("==============================")
print("   DISTRIBUIDORA LA CEIBA")
print("==============================")
print("4 x Aceite 1 L @ 12.50  50.00")
print("Descuento 10 %          -5.00")
print("Base                    45.00")
print("IVA 13 %                 5.85")
print("------------------------------")
print("TOTAL                   50.85")

LEER ventas
SI ventas > 1000 ENTONCES
    comision ← ventas × 0.05
FIN SI
SI ventas > 5000 ENTONCES
    comision ← ventas × 0.08
SINO
    comision ← 0
FIN SI
MOSTRAR comision

LEER ventas
SI ventas > 5000 ENTONCES
    comision ← ventas × 0.08
SINO SI ventas > 1000 ENTONCES
    comision ← ventas × 0.05
SINO
    comision ← 0
FIN SI
MOSTRAR comision

Práctica intensiva

Más práctica para asegurar lo básico: primero ejercicios rápidos que se corrigen solos, luego problemas tipo examen con casos de prueba. Resuélvelos en papel antes de abrir la solución.

Ejercicios rápidos · ¿Qué comando uso?

Escribe solo el comando (sin URL, sin mensaje, sin nombre de archivo, salvo que se pida). Se corrige solo.

# Quiero ver qué archivos cambiaron y en qué estado están

# Quiero preparar TODOS los cambios de la carpeta

# Quiero ver el historial, una línea por commit

# Quiero crear un repositorio en la carpeta actual

# Quiero subir mis commits a GitHub

# Quiero traer lo que subieron mis compañeros

# Quiero cambiarme a la rama main

# Quiero crear la rama "reportes" y cambiarme a ella en un solo comando

• Completé los ejercicios rápidos sin ejecutar el código.

Problemas tipo examen

INICIO
  LEER horas, tarifa
  SI horas < 0 O horas > 60 ENTONCES
      MOSTRAR "revisar"
  SINO
      SI horas <= 40 ENTONCES
          pago <- horas * tarifa
      SINO SI horas <= 48 ENTONCES
          pago <- 40 * tarifa + (horas - 40) * tarifa * 1.5
      SINO
          pago <- 40 * tarifa + 8 * tarifa * 1.5 + (horas - 48) * tarifa * 2
      FIN SI
      MOSTRAR pago
  FIN SI
FIN

INICIO
  LEER ingreso, cuota, deudas, atrasos
  SI atrasos > 2 ENTONCES
      MOSTRAR "ROJO"
  SINO
      carga <- (deudas + cuota) / ingreso
      SI carga > 0.40 ENTONCES
          MOSTRAR "ROJO"
      SINO SI carga > 0.30 ENTONCES
          MOSTRAR "AMARILLO"
      SINO
          MOSTRAR "VERDE"
      FIN SI
  FIN SI
FIN

<<<<<<< HEAD
TASA_IVA = 0.13
=======
TASA_IVA = 0.15
>>>>>>> feature/impuestos

# 1. Editar config.py: dejar solo la línea correcta y borrar los marcadores
TASA_IVA = 0.13

# 2. Marcar el conflicto como resuelto y cerrar el merge
git add config.py
git commit -m "Resuelve conflicto: IVA vigente de 13 %"
git log --oneline      # verificación: aparece el commit de merge

Proyecto integrador · Fase 1

Semana 1 · Definición del problema y setup del repositorio. El proyecto vale el 30 % de la nota y se construye durante todo el ciclo, no al final.

Punto de partida para el .gitignore (GitHub mantiene una plantilla completa: github/gitignore → Python.gitignore):

# Archivos generados por Python
__pycache__/
*.pyc
.pytest_cache/

# Entornos virtuales
.venv/
venv/

# Sistema operativo
.DS_Store
Thumbs.db

Estructura sugerida del README.md (inspirada en lo que pide la Fase 6):

# Nombre del sistema

## Problema de negocio
Quién lo usa, qué decisión le ayuda a tomar, qué proceso manual reemplaza.

## Dominio
Finanzas / retail / logística / servicios…

## Equipo
- Integrante 1 — usuario de GitHub
- …

## Cómo ejecutarlo
(se completa en fases posteriores)

## Supuestos del negocio
Reglas que el equipo decidió y por qué (ej.: el sello se descuenta después del tope).

## Uso de IA
Declaración de qué partes fueron asistidas y cómo se verificaron (obligatorio por política del curso).

Preguntas de defensa (practica en voz alta)

En la sustentación de la semana 11 cada integrante responde preguntas individuales sobre todo el sistema. Empieza a practicar desde ya:

Rumbo al Control 1

El programa ubica el Control 1 en la semana 2. El temario exacto lo confirma el docente en Moodle; esta lista cubre lo de la semana 1. Recuerda: en controles y exámenes no se permite IA.

• Puedo decir si una instrucción es precisa o ambigua, y corregirla.
• Puedo dibujar un diagrama de flujo con los cuatro símbolos y al menos una decisión.
• Puedo trazar un algoritmo a mano con casos normales y de frontera.
• Puedo explicar los tres estados de Git y la diferencia entre add, commit y push.
• Puedo escribir de memoria el flujo de crear rama → commit → merge.

Fuentes

• [BOU] Bouna, P. (2022). Fundamentals of Programming Using Flowchart and Pseudocode. Packt / O’Reilly. Cap. 1.
• [PCC] Matthes, E. (2023). Python Crash Course, 3.ª ed. No Starch Press / O’Reilly. Cap. 1 y Apéndice D.
• [GIT] Chacon, S. y Straub, B. (2014). Pro Git, 2.ª ed. Apress. Libre en git-scm.com/book/es/v2. Cap. 1, 2.2 y 3.1.
• GitHub Docs: SSH · repositorios remotos.

Esta guía resume los temas asignados por el programa del curso; no reproduce el contenido de los libros ni cita páginas. Los libros de O’Reilly son la fuente principal.