jueves, 20 de octubre de 2011

Análisis de la película: "La Sociedad de los Poetas Muertos"

Vasado en el texto: "SENTIDO DE VIDA Y PROCESO DE INDIVIDUACIÓN".



FICHA TÉCNICA PELÍCULA.
Elenco:
Robin Williams, Robert Sean Leonard, Ethan Hawke, Josh Charles, Gale Hansen, Dylan Kussman, Allelon Ruggiero, James Waterson, Kurtwood Smith, Carla Belver y Leon Pownall.
  • Procedencia: EEUU
  • Año: 1989
  • Sinopsis: En 1959 comienza a trabajar, en una estricta escuela estadounidense para varones, John Keating. El mismo es el nuevo profesor de inglés que, con sus poco convencionales métodos, le da nueva vida al ya establecido plan de estudios.




Desarrollo de preguntas
ü  Analicen qué crisis de identidad o sentido viven los siguientes personajes: Incluye en el análisis los qué elementos detonantes y la forma de solución en cada caso, si la hubiese:
             Resp:  
o   Neil Perry: Tenia una gran crisis de identidad, a él no le satisfacía la forma en que su padre lo trataba, su padre lo obligaba a ser lo que él quería y no respetaba sus opiniones. Esta situación llevo a Neil a suicidarse. La situación detonante de este hecho surge al momento en que su padre lo envía a la escuela militar. Se hubiese impedido la muerte de Neil si su padre lo hubiese escuchado desde un principio cuáles eran sus gustos y opiniones, respetando cada una de estas.
o   Todd Andersen: Presentaba problemas de personalidad, era muy tímido con las demás personas impidiéndole expresar sus opiniones y sentimientos con los demás. Con el correr del tiempo y la ayuda de su profesor y Neil logro superar sus problemas de personalidad.  
o   Mr. Keating: Él era profesor, presentaba un crisis de sentido, ya que era muy llevado a sus ideales y pretendía influenciar a sus alumnos con estos.
o   Charlie Dalton (Nuwanda): Mal entendió el concepto de carpe diem, ya que no distinguía entre la valentía y la prudencia.
o   Knox Overstreer: Knox siguió muy al pie de la letra los consejos de Keating sobre el carpe diem, ya que cuando tuvo la oportunidad de “mejorar su vida” no dudo en hacerlo.  
ü  Explica qué elementos de la construcción de Sentido de vida detonan la decisión de Neil de suicidarse.
Resp: El elemento dela construcción de sentido de vida que denota la decisión de Neil es la vida en el seno materno, ya que él era inconsciente en su vida, obedecía a lo que su padre le enviaba y sin oponerse, pero la salir de ese pensamiento se dio cuenta que debía seguir sus sueños y pensamientos, pero al ver que no lo dejaban surgir el decidió terminar con su vida.
ü  Expliquen de qué manera Mr. Keating entiende el concepto “Carpe Diem” a partir de la explicación que da a los estudiantes y de la siguiente frase que él menciona, y enfaticen en la relación de este concepto con el SENTIDO DE VIDA:
El día de hoy no se volverá a repetir. Vive intensamente cada instante. Lo que no significa alocadamente, sino mimando cada situación, escuchando a cada compañero, intentando realizar cada sueño positivo, buscando el éxito del otro, examinándote de la asignatura fundamental: el Amor. Para que un día no lamentes haber malgastado egoístamente tu capacidad de amar y dar vida por lo que continuará...”
         
Resp: Keating entiende el concepto de carpe diem como la forma de vivir cada día al máximo, pero no alocadamente haciéndole mal a las demás personas, sino que escuchando y haciendo lo bueno, para no arrepentirse después de las cosas mal hechas en la vida.

ü  Con qué personaje de la película se siente representado cada uno de los integrantes del grupo de acuerdo a los momentos vividos relacionados con los elementos que dan sentido a la vida, las crisis existenciales vividas, proyectos de vida, necesidades humanas, etc. RESPALDAR CON BIBLIOGRAFÍA.
Resp:
Jorge Henríquez: El personaje que me representa en la película "La Sociedad de los Poetas Muertos", es el personaje Tood Anderson, ya que yo en un momento de mi vida me consideraba una persona muy tímida, pero gracias a la ayuda de amigos y personas cercanas pude superar esta crisis logrando dejar una gran parte atrás.
Cesar Jaramillo: El personaje que escojo de la película es Tood Anderson, básicamente por su personalidad tímida, ya que yo viví una etapa muy parecida en mi pasado y logre superarlos como el. Por este motivo escojo a este personaje, porque me representa más que los demás.


martes, 11 de octubre de 2011

Proyecto PitFinder

Autor: Jorge Henriquez Romero
Competencia: Desarrollo de Software (Nivel 1)
Palabras claves: NXC, Lego, Programacion, PitFinder


Descripción de la actividad
En el siguiente blog daré a conocer los resultados de un proyecto realizado el segundo semestre, el cual fue muy provechoso, porque comenzamos a utilizar arreglos y creación de archivos en NXC.


El proyecto consistió en que un robot debe recorre la meseta de una montaña, y su misión es detectar las alturas de los precipicios de ésta, información que servirá para escaladores, paracaidistas, deportes extremos en general. Esto se guardara en un arreglo y posteriormente pasado a un archivo.

Solución
La solución se demuestra el siguiente Pseudocódigo, en donde se demuestra la forma de solución en palabras.
Pseudocódigo:
Definición de variables, arreglo, umbrales, etc.
sub TraspasaArchivo()
{
  Borra el archivo “Datos.txt”;
  Crea un archivo llamado “Datos.txt”;
  Escribe una cadena que dice "REPORTE PITFINDER";
  Escribe una cadena que dice "------------------";
  Para j=0 y j < ArrayLen(alt) y j++
   {
     Escribe una cadena con los datos tomados;
   }
  Cierra el archivo “Datos.txt”;
} 

sub GuarAlt()              
{
 Guarda en el arreglo “alt” posicion "a" la altura leida;
 Imprime por pantalla la altura leida
 a++;                       
}

task Avanzar()              
{
 Mientras i<4
 {
   Avanzar;
  Si el sensor detecta una altura mayor a “CERCA”;
  {
   i++;       
   Adquiere el semáforo;
   Sigue avanzando por 0.3s;
   Apaga los motores por 1s;
   Ejecuta subrutina "GuarAlt";
   Retrocede 1s;
   Giro aleatorio para encontrar un nuevo precipicio;
   Liberación de semáforo;
  }
 }
 Variable para posicion en la impresion del archivo;
 Variable "bulean" para escribir correctamente las lineas del archivo;
 Detener los motores
 Ejecutar subrutina "TraspasaArchivo";
 Limpia lo escrito en pantalla;
 Abre el archivo creado;
Mientras que la variable bulean sea falsa;
{
  Si no quedan lineas por leer
 {
  Se cambia a verdadera variable bulean;
  Imprime en pantalla la linea leida;
  Disminuye en 10 para imprimir en espacios diferentes;
  Espera 0,5s;
 }
 Espera 5s;
 Cierra el archivo “Datos.txt”;
}

task main()                    
{
 Se ejcuta la tarea Avanzar;
 Setea sensor de ultrasonido;
}
 

El código fuente es el siguiente, y muest5a la solución dada e implementada en el robot.

Código fuente:


int alt[4];            //Arreglo de precipicios
int a=0;   

//Sirve para cambio de posicion de arreglo y posicion de impresion por pantalla
int i=0;               //Veces que se ejecutara el ciclo while
int j=0;               //Veces que se ejecuta ciclo de escritura de archivo
int num=0;
string linea="_=>";    //Para guardar en archivo
string nums;           //Para agregar numero de precipicio en el archivo
string cm= "mts";      //Para guardar en archivo la extension en mts de la altura
byte punteroArchivo;   //fija un puntero para escritura y lectura
string cadena;
byte bytesEscritos;
mutex semaforo;
string leer;
int tam=512;
string mas="precipicio";

#define CERCA 20    //Umbral de la altura fijada

sub TraspasaArchivo()        //subrutina que guarda en archivo
{
 DeleteFile("Datos.txt"); //Borra el archivo creado en la ejcucion anterior del código
 CreateFile("Datos.txt", tam, punteroArchivo);  //crea un archivo nombre, tamaño, y puntero
 WriteLnString(punteroArchivo, "REPORTE PITFINDER", bytesEscritos);
 WriteLnString(punteroArchivo, "--------------------", bytesEscritos);
 for(j=0; j < ArrayLen(alt); j++)
 {
  num++;
  nums= NumToStr(num);
  cadena = NumToStr(alt[j]);
  cadena =  mas + nums + linea + cadena + cm;
  WriteLnString(punteroArchivo, cadena, bytesEscritos);
 }
 CloseFile(punteroArchivo); //Cierra el archivo Creado y escrito
}

sub GuarAlt()        //Subrutina que almacena las alturas en un arreglo
{
 alt[a]=SensorUS(IN_2);  //Guarda en el arreglo posicion "a", la altura leida por el sensor
 NumOut(0,10*a,alt[a]);      //Imprime por pantalla la altura leida
 a++;                        //cambia la posicion que se guardara la proxima vez
}

task Avanzar()               //Tarea Avanzar del programa
{
 while (i<4)                 //Ciclo de ejecucion para la lectura de los 4 precipicios
 {
  OnFwd(OUT_C,50);
  OnFwd(OUT_A,55);           //Avanzar
 
  if (SensorUS(IN_2)>CERCA)  //Si el sensor detecta una altura mayor a "20mts"
  {
   i++;                      //Aumenta en 1 el i para luego salir del ciclo
   Acquire(semaforo);        //Adquiere el semáforo
   OnFwd(OUT_C,50);
   OnFwd(OUT_A,55);
   Wait(300);                //Sigue avanzando por 0.3sec para una mejor lectura
   Off(OUT_AC);
   Wait(1000);               //Apaga los motores por 1sec
   GuarAlt();                //Ejecuta subrutina "GuarAlt"
   OnRev(OUT_C,50);
   OnRev(OUT_A,55);
   Wait(1000);               //Retrocede 1sec
   OnFwd(OUT_C,50);
   OnRev(OUT_A,55);
   Wait(Random(1500)+400);   //Giro aleatorio para encontrar un nuevo precipicio
   Release(semaforo);  //devuelve el semaforo
  }
 }
 int pa=50;          //Para fijar posicion en la impresion del archivo
 bool v_f = false;   //Variable "bulean" para escribir correctamente en pantalla todas las lineas del archivo
 Off(OUT_AC);        //Detener los motores
 TraspasaArchivo();  //Ejecutar subrutina "TraspasaArchivo"
 ClearScreen();  //Limpia lo escrito en pantalla
 OpenFileRead("Datos.txt", tam, punteroArchivo); //Abre el archivo creado
 while (v_f == false)     //Ciclo que se ejecuta mientras la variable bulean sea falsa
 {
  if(ReadLnString(punteroArchivo,leer) != NO_ERR) //Si no quedan lineas por leer
  v_f = true;                                     //Cambia a verdadera variable bulean
  TextOut(LCD_LINE8,pa,leer);   //Imprime en pantalla la linea leida
  pa= pa-10;                    //Disminuye en 10 para imprimir en espacios diferentes
  Wait(500);
 }
 Wait(5000);                    //Espera 5sec para apreciar la impresión
 CloseFile(punteroArchivo);     //Cierra el archivo
}

 
task main()                     {
 Precedes(Avanzar);             //Se ejcuta la tarea Avanzar
 SetSensorLowspeed(IN_2);       //Setea sensor de ultrasonido
}


El siguiente video evidencia que el programa si funciona crrectamente:






Reflexión
El proyecto realizado junto a algunos de mis compañeros, me ayudo bastante a entender cómo funcionaban los arreglos y la creación y guardado de archivos en NXC, además de promoverme el trabajo en grupo, el cual es muy importante en la carrera de ing. Civil en informática. En conclusión, fue muy enriquecedora para mí, y me permitió entender mejor el funcionamiento del robot Lego NXT.

Espero les haya servido el contenido de este blog, porque a mí me sirvió bastante en el desarrollo de futuros proyectos.

Programación con ciclos anidados

Autor: Jorge Henriquez Romero
Competencia: Desarrollo de Software (Nivel 1)
Palabras claves: Programación, NetBeans, Ciclos



Descripción
En el siguiente blog les daré a conocer un trabajo que me ayudó mucho en el aprendizaje en programación, y espero a ustedes tambien, me refiero a los ciclos anidados.
El trabajo consistía en crear un programa, dado por la profesora, en el programa NetBeans  y consistía en analizar y resolver el problema de ingresar un número,  luego mostrarlo en el orden inverso. Por ejemplo:
23613 -> [P] -> 31632

Solución
La solución para este problema está dada en el siguiente código desarrollado en el programa NetBeans.
import java.util.*;
public class Ejercicio {
    private static int i, j;
    public static void main(String[] args) {
       String num;
       int X=0;
       int a=0;
       int nuevo=0;
       Scanner l=new Scanner(System.in);
       System.out.println("Ingrese un numero, y este se mostrara en orden inverso");
       num=l.next();
       int largo=num.length();
       int largo2=num.length();
       int numX = Integer.parseInt(num);
       for(i=0;i<largo;i++){
           int pos=1;
           for(j=0;j<largo2;j++){
               pos=pos*10;
           }
         X=numX%10;
         pos=pos/10;
         nuevo=nuevo+X*pos;
         numX=numX/10;
         largo2--;
       }
       System.out.println("El numero es: "+nuevo);
    }
}
La imagen siguiente muestra que el programa funciona correctamente.

Reflexión
La programación de este trabajo me ayudo bastante en la programación de futuros problemas, además me permitió ver cómo funcionaban los ciclos anidados y en donde colocarlos. No es tan sencillo el tema de los ciclos anidados, ya que uno debe poner mucho cuidado en la definición de variables, entre otras cosas.
Espero les ayude el contenido de este blog, para mí fue muy provechoso.

Mi primer programa con if y else

Autor: Jorge Henriquez Romero.
Competencia: Desarrollo de Software (Nivel 1).
Palabras Claves: if, Programacion, java, Bluej.



Descripción de la actividad
En este blog compartiré mi experiencia que obtuve al realizar mi primera programación en java con las sentencias if y else.
La tarea consistía  en escribir un programa que una vez leído una hora en formato “hora, minuto, segundo” indique cual será el tiempo dentro de un segundo, esto debía realizarse en el programa Bluej.
Ejemplo: 

          
Caso1
Caso2  
Caso3
Caso4
Caso5
Hora
8
9
18
20
23
Minuto
55
57
50
59
59
Segundo
42
50
59
59
59


           +1 segundo
Caso1
Caso2  
Caso3
Caso4
Caso5
Hora
8
9
18
21
00
Minuto
55
57
51
00
00
Segundo
43
51
00
00
00



Solución
La solución del problema está dada en el siguiente código, en donde se implementa las sentencias if/else para resolver el problema:

Código: 
import java.util.*;
public class HORA
{
  public static void main()
  { int r, h, m, s;
   Scanner leer = new Scanner(System.in);
   System.out.println("inserte una hora en el formato hora minuto segundo");
   System.out.print("Inserte Hora: ");
   h=leer.nextInt();
   System.out.print("Inserte Minuto: ");
   m=leer.nextInt();
   System.out.print("Inserte Segundo: ");
   s=leer.nextInt();

   if(s+1<60){
   System.out.println("===================");   
   System.out.println("La hora es ="+h+":"+m+":"+(s+1));
   }
   else if(m+1<60){
        System.out.println("===================");
        System.out.println("La hora es ="+h+":"+(m+1)+":"+"00");
        }
         else if(h+1<24){
           System.out.println("===================");
           System.out.println("La hora es ="+(h+1)+":00:00");
               }
            else
             System.out.println("===================");
             System.out.println("La hora es =00:00:00");
   }
}

En esta imagen se muestra que el programa funciona correctamente.

 
Reflexión
Fue importante este punto de la programación, ya que con las sentencias if/else, se abre una gran gama de posibilidades para crear nuevos programas. Me ayudo a ver los problemas con otra mentalidad, ya que se volvieron más difíciles y necesitaban mayor atención. Además me permitio entender mejor la forma de programar en el programa Bluej.
Espero les ayude el contenido de este blog, a mí me ayudo bastante el desarrollo de este trabajo para entender mejor las sentencias if/else, y en el funcionamiento de Bluej.