Clases orientadas al aprendizaje

Clases orientadas al aprendizaje
(en las primeras asignaturas de Computación)
Teaching oriented lectures
considered harmful
Juan Alvarez Rubio
[email protected]
Talca, Noviembre 2006
Clase tradicional
•
•
•
•
•
•
•
centrada en profesor
énfasis en contenidos (“pasar materia”)
alumnos pasivos, receptores
sesiones sin estructura (e interminables)
objetivos se miden sólo en evaluaciones
enseña a leer, evalúa escribir (programar)
en resumen, clase orientada a la enseñanza
Clase orientada al aprendizaje
•
•
•
•
•
•
•
centradas en estudiantes
énfasis en objetivos
profesores como facilitadores de aprendizaje
sesiones orientadas a resolver problemas
apoyo logístico y tecnológico
ayudantías siguen mismo modelo
sesiones estructuradas
Estructura de una sesión de clases
1. profesor presenta contenidos resolviendo
un problema
2. estudiantes resuelven un problema
3. profesor presenta y analiza soluciones
1. Profesor presenta contenidos
0. Distribuye material a estudiantes
1. Presenta problema
2. Muestra algoritmo (si corresponde)
3. Presenta programa
4. Explica sintaxis y semántica
Tiempo: 30-45 minutos
Ejemplo: Métodos recursivos
Problema. Escribir una función que calcule el factorial de un
entero positivo. Por ejemplo, 4!=24=1*2*3*4 y 0!=1
Solución 1 (iterativa): x! = 1*2*...*x
(0!=1)
Solución 2 (recursiva): x! = x * (x-1)!
static public int factorial(int x)
{
if( x == 0 )
return 1;
else
return x * factorial(x-1);
}
(0!=1)
2.Estudiantes resuelven problema
1. Profesor presenta problema
2. Profesor distribuye hojas de respuestas
3. Estudiantes trabajan individualmente
4. Profesor recolecta hojas de respuesta (y las
clasifica)
5. Profesor (+ayudantes) corrige, sin calificar,
y entrega en la siguiente clase
Tiempo: 15-30 minutos
Problema. Escribir una función recursiva que
calcule xy (x:real, y:entero)
sin usar Math.pow(x,y)
Ejemplos:
potencia(2.0,3) = 8.0
potencia(2.0,-3) = 0.125
potencia(2.0,0) = 1.0
3. Profesor analiza soluciones
1. distribuye hoja con soluciones
2. presenta/explica solución más popular
(intuitiva, natural, directa)
3. presenta/explica solución alternativa
(“mejor”, breve, eficiente, elegante...)
Tiempo: 15-30 minutos
Solución 1. xy: 1 si y=0, 1/x-ysi y<0, x xy-1 si y>0
static public double potencia(double x,int y){
if( y==0 )
return 1.0;
else if( y < 0 )
return 1.0/potencia(x,-y);
else
return x * potencia(x,y-1);
}
alternativamente
if( y == 0 ) return 1;
if( y < 0 ) return 1/potencia(x,-y);
return x * potencia(x,y-1);
Nota. Realiza y-1 llamadas recursivas
Solución 2. xy: xy/2 xy/2 si y par; x x(y-1)/2 x(y-1)/2 si y impar
static public double potencia(double x,int y){
if(y==0) return 1.0;
if(y<0) return 1.0/potencia(x,-y);
double aux;
if(y%2==0){
aux=potencia(x,y/2);
return aux*aux;
}else{
aux=potencia(x,(y-1)/2);
return x*aux*aux;
}
}
Solución 2 abreviada
static public double potencia(double x,int y)
{
if(y==0) return 1.0;
if(y<0) return 1.0/potencia(x,-y);
double aux=potencia(x,y/2);
if(y%2==0)
return aux*aux;
else
return x*aux*aux;
}
Nota. Realiza log2y+1 llamadas recursivas
Primera clase tradicional
•
•
•
•
Discurso (monólogo) del profesor
contenido: historia de la disciplina
alumnos pasivos
eventualmente alumnos inquietos realizan
preguntas con tecnicismos
• sesión sin estructura
• orientada a enseñanza y no aprendizaje
1ª clase orientada al aprendizaje
1ªparte: profesor resuelve problema
• presenta problema sencillo
• deduce algoritmo (con estudiantes)
• presenta programa
• explica sintaxis y semántica
Tiempo: 45-60 minutos
2ª parte: estudiantes
• resuelven individualmente problema simple
del área de ciencia e ingeniería
• aprenden sintaxis y semántica
• sin calificación
Tiempo: 15 minutos
3ª parte: profesor
•
•
•
•
presenta primera solución
analiza errores más frecuentes
presenta 2ª solución con nuevas facilidades
propone nuevos problemas
– seguir/diseñar diálogo
– inventar problema
Tiempo: 15 minutos
Conclusiones
centro
orientación
enseñanza
profesor
orientación
aprendizaje
estudiante
énfasis
contenidos
objetivos
profesor
“gurú”
facilitador
estudiante
pasivo
(lee/escucha)
sin estructura
activo
(programa)
3 partes
clases
Conclusiones...
Orientación
Enseñanza
duración clase interminable
Orientación
Aprendizaje
llevadera
planificación
menos tiempo más tiempo
objetivos
evaluaciones
c/clase
logística
mínima
imprescindible
1ªclase
discursiva
3 partes
sgtes cursos
tradicionales
desafío
Contenido: listas enlazadas Curso Alg y Est de Datos
Introducción profesor : Implementar TDA Stack
Operación
significado
new Stack()
void push(Object x)
throws StackFull
x
Object pop( )
throws StackEmpty
void reset( )
boolean empty( )
¿
?
boolean full( )
¿
?
Problema alumnos: implementar la clase Queue.
Operación
significado
new Queue()
void enque(Object x)
throws QueueFull
x
Object deque( )
throws QueueEmpty
void reset( )
boolean empty( )
¿
?
boolean full( )
¿
?
Solución 1 :
primero
A
valor sgte
B
valor sgte
class Queue
{
protected Nodo primero;
public Queue(){
primero=null;
}
…
Nota. deque O(1) y enque O(n)
C
null
valor sgte
Solución 2
primero
A
valor sgte
B
valor sgte
C
ultimo
class Queue
{
protected Nodo primero, ultimo;
public Queue(){
primero=ultimo=null;
}
…
Nota. enque y deque O(1)
null
sgte
Contenido Grafos: árbol cobertor mínimo
Introducción del Profesor
• problema
• algoritmo Kruskal
Ordenar los arcos E en orden creciente de costo
C={ {v} / v está en V}; //el conjunto de las componentes conexas
while( |C| > 1 ){
Sea e=(v,w) el sgte arco en orden de costo creciente;
if( find(v) != find(w) ){
agregar e al arbol;
Union(find(v),find(w));
}
}
• implementación
Problema alumnos: implementar Algoritmo Prim
Sea e=(v,w) un arco de costo mínimo en E;
Agregar e al árbol;
A={v,w}; //conjunto alcanzable
while( A ≠ V )
{
Encontrar el arco e(v,w) más barato con v en A y w en V-A;
Agregar e al árbol;
Agregar w a A;
}