domingo, 13 de abril de 2014

GitHub

Introducción

En este texto se habla sobre github, las empresas que lo utilizan, sus características, ventajas, desventajas y la forma de usarlo.

Desarrollo

¿Qué es Github?

Es una plataforma lanzada en el año 2008 para desarrollar proyectos de software en equipo usando un controlador de versiones. JQuery, reddit, node.js y otras empresas de software libre lo utilizan por su gran funcionalidad.

Sus principales herramientas son:

  • Wikis (páginas web que pueden ser editadas por distintos usuarios) para el mantenimiento de distintas versiones de las páginas.
  • Visor de ramas. Donde se pueden analizar y comparar los progresos en el desarrollo del proyecto.U
  • Revisor de código. Para realizar anotaciones en cualquier parte del código.
  • Sistema de seguimiento de problemas. Con el objetivo de que los miembros del equipo puedan hacerse críticas y sugerencias sobre su software.

Ventajas

  • Al subir código, se puede decidir si cualquier usuario puede editarlo o darle permisos a algunos para realizar cambios.
  • Tiene un visor de código que resalta el código dependiendo del lenguaje usado.

Desventajas

  • Es díficil aprender a usarlo, ya que no es nada intuitivo.
  • Ofrece espacio limitado.

¿Cómo se usa?

Aquí hay distintas páginas para aprender a utilizarlo:
http://www.saulcintero.com/como-versionar-un-proyecto-en-github-con-eclipse-y-git/
http://conociendogithub.readthedocs.org/en/latest/data/dinamica-de-uso/
http://chronometreur.wordpress.com/2011/03/01/como-usar-github/

Conclusión

Github es un útil sistema de desarrollo de software en equipo, ya que permite visualizar los cambios hechos por los distintos usuarios en el proyecto, así como modificarlo, sin preocuparse por perder las versiones anteriores ni de donde estan alojadas. 

domingo, 2 de marzo de 2014

Reingeniería

Introducción

El siguiente trabajo es un resumen de lo que son la reingeniería y sus etapas. Esto sirve porque es una parte importante en el ciclo de vida de un proyecto de software, sobre todo cuando el software ya tiene mucho tiempo de ser usado.

Desarrollo


Reingeniería


Es el reconstruir un producto que ha funcionado bien, pero que con el tiempo presenta muchas fallas, creando un producto más funcional, con un mejor desempeño, fiabilidad y facilidad del mantenimiento.
La realizan a cabo especialistas en negocios, o en el caso del software, un ingeniero de software. Es necesaria porque conforme el mundo cambia, los negocios cambian, el software que soporta el negocio también debe cambiar.

Etapas


Reingeniería de procesos de negocios (RPN)

Se define como: "La búsqueda e implementación de un cambio radical en el proceso de negocios para lograr resultados de vanguardia".
Un proceso de negocio es un conjunto de tareas lógicamente relacionada que se ejecutan para lograr un resultado de negocios específicos. Dentro del mismo la gente, el equipo, los recursos materiales y los procedimientos del negocio se combinan para llegar a un resultado específico.
Cada sistema de negocio está compuesto por uno o más procesos de negocio y cada uno tiene varios subprocesos.
La reingeniería de procesos de negocio es iterativa. Tiene definidas seis actividades:
1. Definición del negocio. Las metas del negocio se identifican desde cuatro controladores clave: reducción de costo, reducción de tiempos, mejora de calidad y desarrollo y fortalecimiento del negocio.
2. Identificación del proceso. Se identifican los procesos cruciales para lograr las metas precisadas en la definición del negocio.
3. Evaluación del proceso. El proceso existente se analiza y mide exhaustivamente.
4. Especificación y diseño del proceso. Se preparan casos de uso para cada proceso que será rediseñado.
5. Elaboración de prototipos. El proceso de negocio rediseñado debe convertirse en prototipo antes de integrarse al negocio.
6. Refinamiento y particularización. Con base en la retroalimentación del prototipo, el proceso de negocio se refina y luego se particulariza dentro del sistema de negocio.
En ocasiones, estas actividades se utilizan con las herramientas de flujo de trabajo. Estas herramientas permiten al analista modelar los procesos de negocio existene para evaluar las ineficiencias del flujo de trabajo.

Reingeniería del software


Ocurre cuando al software ya no sé le puede dar mantenimiento, debido a la falta de buenas prácticas de ingeniería del software.
La reingeniería requiere tiempo, cuesta cantidades significativas de dinero y abosrbe recursos que de otro modo se ocuparían en problemas inmediatos. Se necesita una estrategia pragmática para realizarla.
Las siguientes fases son un modelo ciclíco de un paradigma de la reingeniería:
1. Análisis de inventarios. Las organizaciones de software deberían tener un inventario de todas sus aplicaciones. Al ordenar esta información, aparecen los candidatos para reingeniería y se les pueden asignar recursos.
2. Reestructuración de documentos. La documentación débil caracteriza a muchos sistemas heredados. Existen varias opciones para atacar el problema:
I. Crear documentación consume muchísimo tiempo. Si el sistema funciona vivirá con lo que se tenga. No es posible recrer documentación pra cientos de programas de computadora.
II. La documentación debe actualizarse, pero se tienen recursos limitados. Se debe documentar aquellas porciones del sistema que en la actualidad experimentan cambios.
III. El sistema es crucial para el negocio y debe volver a documentarse por completo. Un enfoque inteligente es recortar la documentación a un mínimo esencial.
3. Ingeniería inversa
Es el proceso de analizar un programa con la finalidad de crear una representación del programa en un mayor grado de abstracción que el código fuente. Es un proceso de recuperación de diseño. Las herramientas de la ingeniería inversa obtienen información del diseño de datos, arquitéctonico y de procedimientos a partir de un programa existente.
4. Reestructuración
Modifica el código fuente o los datos con finalidad de adecuarlos para futuros cambios.
Reestructuración de código. Algunos sistemas heredados tienen una arquitectura de progrma que dificulta comprenderlos, probarlos y mantenenerlos, en tales casos se puede reestructurar el código dentro de los módulos sospechosos.
Reestructuración de datos. Inicia como una actividad de ingeniería inversa. La arquitectura de datos se analiza con minuciocidad y se definen los modelos de datos necesarios. Se identifican los objetos de datos y los atributos, y se revisa la calidad de las estructuras de datos existentes.
5. Ingeniería directa
Recupera la información del diseño a partir del software existente y la utiliza para alterar o reconstituir el sistema existente con la finalidad de mejorar su calidad global.
Se divide en ingeniería directa para arquitecturas cliente/servidor e ingeniería directa para arquitecturas orientadas a objetos.

Conclusión

Con el desarrollo de este trabajo, comprendí el concepto de reingeniería de software y los procesos que conlleva su realización. Es importante utilizarla porque a medida que un sistema se hace viejo y se le aplica mantenimiento, se vuelve obsoleto y por tanto, se debe tener algo que le devuelva su estructura,

domingo, 16 de febrero de 2014

Mantenimiento y Leyes de Lehman

Ejemplos de mantenimiento

Mantenimiento preventivo. League Of Legends: Para preveer la entrada de los usuarios, ya que su cantidad ha aumentado considerablemente desde su lanzamiento, por lo que tienen que revisar la capacidad de sus servidores.
Mantenimiento correctivo. Netbeans: Contiene muchos bugs y tarda mucho en iniciarse y crear y abrir nuevos proyectos.
Mantenimiento adaptativo. Microsoft Word 2010: Lo adaptaría para otros sistemas operativos, puesto que sólo funciona en Windows.
Mantenimiento perfectivo. WinDS Pro: Este programa es un conjunto de emuladores de consolas de Nintendo, y le aplicaría mentenimiento perfectivo para que pudiera emular el Nintendo 3DS y utilizar sus juegos.

Ley del Cambio Continuo (1era Ley de Lehman) 

http://aristeguinoticias.com/3007/kiosko/se-cumplen-10-anos-del-ultimo-vocho-en-mexico/

En esta noticia podemos encontrar un ejemplo de la primera ley, es sobre el último vocho producido en México, especificamente, en Puebla. Este vehículo fue producido primero en Alemania y después en todo el mundo, hasta en México.

Logró gran aceptación alrededor del planeta, sin embargo, debido a que permanecio sin cambios por mucho tiempo, su producción y ventas comenzaron a decaer, hasta que en 1971 dejo de producirse en Alemania y en 2004 en todo el mundio. Esto refleja lo que quiere decir la primera ley, puesto que un sistema necesariamente tiene que cambiar o sí no se volverá menos útil para su entorno. El Volkswagen Sedán al no cumplir con esta ley y al no ser modificado, fue sacado del mercado.


José Antonio Jiménez Amador. 

Ley de Complejidad creciente: (2da Ley de Lehman)

http://www.eluniversal.com.mx/ciudad-metropoli/2013/sube-tarifa-del-metro-a-5-el-dia-13-de-diciembre-971265.html
La noticia que se tomó como base para poder explicar la segunda ley, se trata de una noticia reciente que hace referencia a el aumento del precio en el metro de la ciudad de México.
A pesar de su mala aceptación por parte de los usuarios que utilizan este medio de transporte público podemos citar que la segunda ley nos menciona que a medida que un programa en evolución camba, su estructura tiende a ser más compleja y se debe requerir recursos extras para perseverar y simplificar su estructura.
En base al artículo, podemos ver que el alza en el precio del metro es destinar recursos extras para poder mejorar el sistema de transporte público, en este caso comprar más trenes nuevos para mejorar los tiempos de recorrido de los trenes, ya que podemos observar que las personas que hacen uso de este servicio son demasiadas.   

Reyes Fragoso Roberto

Ley de Autorregulacion  (3ra Ley de Lehman)

http://www.softzone.es/2013/09/11/problemas-con-las-actualizaciones-de-microsoft-en-windows-7-8-y-8-1/

Esta noticia es un ejemplo de cómo entre más grande sea el sistema más complicado es aplicarle mantenimiento, pues Windows al ser un sistema operativo, entre más complejo sea el cambio o más grande sea el número de actualizaciones, podría traer más errores como los mencionados en la noticia. Por otro lado, si se hubieran aplicado pequeños cambios jerarquizados por relevancia, tal vez éstas actualizaciones no hubieran provocado los malos resultados que se destacan en la noticia.


Hernández Uribe Oswaldo Daniel


Ley de la estabilidad organizacional. 

http://noticias.softonic.com/firefox-para-windows-8-se-retrasa-de-nuevo-podria-salir-en-marzo
En la noticia anterior se muestra el retraso que ha tenido el lanzamiento Firefox para la interfaz Modern de Windows 8 y Windows 8, ya que desde el 2012 han salido gran cantidad de bugs que impiden la publicación de la app de Firefox. El desarrollo es una etapa constante, y no se puede apresurar dedicándole mas recursos, ya que detrás de todo esto, hay un análisis de requerimientos, y una planeación que no puede ser “modificada”.
Debe de haber un análisis correcto, contemplar las pruebas, y desarrollarlo con el tiempo acordado, ya que puede llegar el caso en el que apresurar el desarrollo del software, puede causar errores en el mismo, aun con los recursos adecuados.

Lara Hernández Ricardo. 

Ley de la conservación de la familiaridad (5 ta ley de Lehman)

http://www.elsiglodetorreon.com.mx/noticia/962397.brotan-aguas-negras-por-el-crecimiento-poblacional.html
En la noticia anterior apreciamos un ejemplo de la quinta ley de Lehman, trata sobre el desbordamiento de un canal de aguas negras en Torreón provocado por el aumento poblacional en las áreas alrededor de este. Mencionan que debido a la saturación de las líneas que cruzan por el lugar, así como el aumento de materiales sólidos que al acumularse en cierto punto, bloquean el flujo normal de las aguas hacia la planta tratadora, y hacen que las aguas se desborden. Se puede notar la primera ley en que el aumento a un sistema, en este caso una civilización, provoca defectos en el mismo, y se debe dar una segunda "entrega" y reparar los mismos.

Esquivel Sánchez Luis Rodrigo.

domingo, 9 de febrero de 2014

Mantenimiento de software

Introducción

El presenta trabajo aborda el tema de mantenimiento de software. Es importante tener presente este concepto, puesto que actualmente, se invierte más tiempo en realizar el mantenimiento que en desarrollar el proyecto de software.

Desarrollo

Mantenimiento de software

Es la modificación de un proyecto de software después de haber sido entregado al cliente, ya sea en el código o en la documentación, debido a un defecto o por las necesidades cambiantes del cliente. (Sánchez Barreiro).

Soporte de software

El soporte de software es el servicio que asiste sobre el software de una computadora u otro dispositivo, para ayudar al usuario a resolver algún problema que se presente al utilizarlo.

Tipos de mantenimiento

Correctivo. Para eliminar los defectos del producto después de que ocurra un error.
Adaptativo. Es el modificarlo para funcionar bajo algún cambio en el entorno (software o hardware) donde se ejecuta.
Perfectivo. Es provocado por cambios en la especificación, añadiendo nuevas funciones pedidas por el cliente.
Preventivo. Es corregir ciertas propiedades del software, antes de que se presente un error. Ayuda a reducir los tiempos que se pueden gastar en el mantenimiento correctivo. (Tlaxcala)

Mantenimiento dentro del ciclo de desarrollo de software

El mantenimiento entra al final del ciclo de cascada, después de que el software ha sido entregado e implementado. 

Preguntas

1. ¿Cuáles son los factores que elevan el costo del mantenimiento?

a) Estabilidad del equipo. Cuando se entrega el sistema, el equipo desarrollador normalmente  de disuelve, por lo que el equipo de mantenimiento no comprende el sistema, lo cual se debe hacer para implementar cambios en él.
b) Responsabilidad contractual. El contrato con quien desarrollo el sistema y el que lo mantiene es distinto, por lo que el equipo desarrollador no se preocupa en que el sistema sea fácil de modificar, lo que aumenta el costo.
c) Habilidades del personal. El personal de mantenimiento a menudo no posee experiencia y no domina la aplicación.
d) Edad y estructura del sistema. A medida que pasa el tiempo la estructura de los programas se degrada con los cambios, por lo que se vuelve difícil de comprender y modificar.

2. ¿Qué debe considerar en el entorno para realizar cambios en el sistema?

a) El número y complejidad de las interfaces del sistema. Cuanto mayor sea su número y más complejas, es más probable que se hagan peticiones de cambio.
b) El número de requerimientos del sistema intrínsecamente volátiles. Son los que reflejan políticas y procedimientos organizacionales, a diferencia de los que se basan en características estables del dominio
c) Los procesos de negocios en los que se utiliza el sistema. Como los procesos de negocios evolucionan, se generan más peticiones de cambio del sistema.


Conclusión

Con este trabajo he comprendido lo que es el mantenimiento del software, la diferencia que tiene con el soporte de software, los tipos de mantenimiento de software, las consideraciones que se deben tomar al realizar cambios y los factores que elevan los costos de la realización de los mismos.

Bibliografía

Sánchez Barreiro, P. (s.f.). Ingenieria de software II. Recuperado el 2014 de Enero de 28, de http://ocw.unican.es/ensenanzas-tecnicas/ingenieria-del-software-ii/materiales/tema8-mantenimientoSistemasSoftware.pdf


Tlaxcala, U. A. (s.f.). Mantenimiento de software. Recuperado el 28 de Enero de 2014, de http://ingenieria.uatx.mx/labastida/files/2011/08/MANTENIMIENTO-DE-SOFTWARE.pdf

viernes, 29 de noviembre de 2013

Justificación del porque mi proyecto es distribuido

El proyecto Aeroseth es distribuido porque se ejecuta dentro de una red de computadoras que comparten información a través de un protocolo.

Cada computadora puede tener o no la misma hora, y aunque sea distinta, la comunicación entre las mismas no se ve distorsionada, puesto que se sincronizan utilizando mensajes.

Las computadoras envían y reciben información, con el objetivo de satisfacer las necesidades de la empresa Aeromar, entre las cuales están: la falta de un control en la entrada y salida de piezas, un registro de las bitácoras realizadas por los mecánicos, la planeación de las fechas de reparación y de los vuelos y la administración del personal.

Si dentro de la red, alguna computadora falla o presenta un desperfecto, las demás no resultan afectadas por el error.

Se pueden agregar varias computadoras al sistema original sin que haya errores entre las mismas, y pueden poseer distintas características, pero de preferencia deben poseer Windows 7.

Las unidades de procesamiento pueden realizar distintas tareas, como navegar por internet, reproducir música o escribir algún texto, al mismo tiempo que se comunican entre ellas.

miércoles, 20 de noviembre de 2013

Clase ClienteJuego

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ahorcado;

import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import javax.swing.JOptionPane;

/**
 *
 * @author Alumnos
 */
public class ClienteJuego extends Frame implements ActionListener{
    private TextField letra = new TextField(1);
    private Label palabra = new Label("");
    private Label letras_ocupadas = new Label("");
    private Label ganador = new Label("");
    private Button ok = new Button("Ingresar");
    private Graphics g;
    private int comparador[];
    private String palabra_actual = "";
    private int errores = 0;
    Label turno;
    Label turno2;
    int jugador;
   
    BufferedReader entrada;
     PrintWriter salida;
    public ClienteJuego(){
        super("Juego del Ahorcado");
        Socket socket = new Socket();
        try {
            socket = new Socket("localhost",2250);
            entrada = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            salida = new PrintWriter(socket.getOutputStream(), true);
            Thread lectura = new Thread( new Lector());
            lectura.start();
            System.out.println("Conexion Establecida con Servidor");
           
        } catch (IOException e) {
            System.err.println("No se pudo establecer la conexión");
            System.exit(1);
        }
       
        setLayout(new BorderLayout());
        setBackground(Color.yellow);
        setResizable(false);
        Canvas canvas = new Canvas();
        canvas.setSize(200,300);
        Panel p = new Panel(new GridLayout(5,1));
        Panel p1 = new Panel();
        turno = new Label("Es Turno del jugador 1 : ");
        turno2 = new Label("Es Turno del jugador 1 : ");
       
        p1.add(turno);
        p1.add(letra);
        p1.add(ok);
        Panel p2 = new Panel();
        p2.add(new Label("Palabra : "));
        p2.add(palabra);
        Panel p3 = new Panel();
        p3.add(new Label("Ha ingresado las siguientes Letras : "));
        p.add(p1);p.add(p2);p.add(p3);p.add(letras_ocupadas);p.add(ganador);

        add("West",canvas);
        add("Center",p);
        ok.addActionListener(this);
        addWindowListener(new WindowAdapter(){
        public void windowClosing(WindowEvent w){
        System.exit(0);
        }});

        setSize(500,330);
        show();
        g = canvas.getGraphics();
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String l = String.valueOf( letra.getText().charAt(0) );
        System.out.println("La letra a mandar es: " + l);
        salida.println(l.toUpperCase());
        System.out.println("Mandando Letra a salida");
    }
   
    public static void main( String args[] ){
       
        new ClienteJuego();
    }
    private class Lector implements Runnable{
        String cadena;
        @Override
        public void run() {
            try {
                while(true){
                    cadena = entrada.readLine();
                    if( cadena != null ){
                        System.out.println("Recibiendo distinto de nulo en cliente");
                        String caracter = String.valueOf(cadena.charAt(2));
                        System.out.println("Caracter es: " + caracter );
                        if( cadena.charAt(0) == 'N' ){
                           
                            jugador = cadena.charAt(1) - 47;
                            setTitle("JUGADOR " + jugador);
                            palabra_actual = cadena.substring(2).trim();
                            String aux = "";
                            System.out.println(palabra_actual);
                            comparador = new int[ palabra_actual.length() ];
                            System.out.println("llega");
                            for(int i = 0; i < palabra_actual.length(); i++){
                                aux = aux + "_ ";
                                comparador[i] = 0;
                            }
                            System.out.println("el auxiliar es: " + aux);
                            palabra.setText(aux);
                        }else if( cadena.charAt(0) == 'C' ){
                             if( (cadena.charAt(4)-47) == jugador ){
                                 letra.enable(true);
                                turno.setText("Ingresa una letra:");
                            }else{
                                 letra.enable(false);
                                turno.setText("Espera tu turno:");
                            }
                            String aux="";
                            for(int i = 0; i < comparador.length; i++){
                                if(caracter.equals(""+palabra_actual.charAt(i)) ){
                                    comparador[i] = 1;
                                }
                                if(comparador[i]==1)
                                    aux += palabra_actual.charAt(i);
                                else
                                    aux += "_ ";
                            }
                            palabra.setText(aux);

                        }else if( cadena.charAt(0) == 'I'  ){
                            System.out.println("el jugador es: " + jugador );
                            System.out.println("Y el caracter es: " + (cadena.charAt(4)-47) );
                            if( (cadena.charAt(4)-47) == jugador ){
                                letra.enable(true);
                                turno2.setText("Ingresa una letra: ");
                            }else{
                                turno2.setText("Espera tu turno:");
                                letra.enable(false);
                            }
                            turno.setText("");
                            errores++;
                            String aux = letras_ocupadas.getText();
                            if( aux.indexOf(caracter) < 0 )
                                aux += " " + caracter;
                            letras_ocupadas.setText(aux);
                            switch(errores){
                                case 1:
                                    g.setColor(Color.red);
                                    g.fillRect(110,220,30,10);break;
                                case 2:
                                    g.fillRect(120,20,10,200);break;
                                case 3:
                                    g.fillRect(70,20,50,10);break;
                                case 4:
                                    g.fillRect(68,20,5,20);break;
                                case 5:
                                    g.setColor(Color.black);
                                    g.drawOval(50,40,40,40);break;
                                case 6:// Cuerpo
                                    g.drawLine(70,80,70,150);break;
                                case 7:// Brazos
                                    g.drawLine(70,100,40,100);break;
                                case 8:
                                    g.drawLine(70,100,100,100);break;
                                case 9:// Piernas
                                    g.drawLine(70,150,40,190);break;
                                case 10:
                                    g.drawLine(70,150,100,190);
                                    ganador.setText("Perdiste!!!");
                                    palabra.setText(palabra_actual);
                            }
                        }else if(cadena.charAt(0) == 'P' ){
                            String puntos = cadena.substring(1);
                            JOptionPane.showMessageDialog(null, "Has Perdido con " + puntos);
                        }else{
                            String puntos = cadena.substring(1);
                            JOptionPane.showMessageDialog(null, "Has Ganado con " + puntos);
                        }
                    }
                   
                }
            } catch (Exception ex) {
                ex.printStackTrace();
                System.out.println("CONEXIÓN FINALIZADA");
               System.exit(0);
            }
        }
    }
}

Clase ServidorJuego

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package ahorcado;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.*;
import java.util.Random;
import java.util.logging.Level;
import java.util.logging.Logger;


/**
 *
 * @author Alumnos
 */
public class ServidorJuego {
    public static final int PUERTO = 2250;
    Socket jugadores[] = new Socket[100];
    int puntos[] = new int[100];
    BufferedReader entrada[] = new BufferedReader[100];
    PrintWriter salida[] = new PrintWriter[100];
    Thread hilos[] = new Thread[100];
    String palabras[] = {"Victor","Francisco","investigacion", "Archivo",
                "Computacion","Astronomia","Ingenieria",
                "Felicidad","Salud","Dinero","Energia",
                "Fuerza","Flojera"};
    public String actual = "lkdjakj";
    String respuesta;
     int contador;
    int errores;
    int turnoActual;
    int numJugadores = 4;
    Random generador = new Random();
    public static void main( String args[] ){
        new ServidorJuego().inicia();
    }
    public ServidorJuego(){
        actual = palabras[generador.nextInt(palabras.length-1)].toUpperCase();
    }
    public void inicia(){
        System.out.println(actual);
        try {
            ServerSocket servidor = new ServerSocket(PUERTO);
           
            for( int i = 0; i < numJugadores; i++ ){
                jugadores[i] = new Socket();
                System.out.println("Esperando jugador " + i+1);
                jugadores[i] = servidor.accept();
                System.out.println("Aceptado ");
                System.out.println("Palabra: " + actual );
                entrada[i] = new BufferedReader( new InputStreamReader( jugadores[i].getInputStream() ) );
                salida[i] = new PrintWriter(jugadores[i].getOutputStream(), true);
                salida[i].println("N" + i + " " + actual);
            }
           
            System.out.println("Palabra: " + actual );  
            System.out.println("Turno Actual " + turnoActual );
            while( contador < actual.length() && errores < 10 ){
                System.out.println(" contador de correctas = " + contador);
                System.out.println("Numero de errores: " + errores );
                String cadena = entrada[turnoActual].readLine();
                if( cadena != null ){
                    System.out.println("Distinto de nulo");
                    char letra = cadena.charAt(0);
                    System.out.println("Letra recibida: "  + letra );
                    if( actual.indexOf(letra) != -1){
                        System.out.println("Letra Encontrada");
                        int temp = 0;
                        for( int i = 0; i < actual.length(); i++ ){
                            if( actual.charAt(i) == letra ){
                                temp++;
                            }
                        }
                        System.out.println("Se encontro " + temp + " veces");
                        contador += temp;
                        System.out.println("El contador es " + contador);
                        puntos[turnoActual] += (temp*10);
                        turnoActual++;
                        if( turnoActual == numJugadores ){
                            turnoActual = 0;
                        }
                        for( int i = 0; i < numJugadores; i++ ){
                            salida[i].println("C " + letra + " " + turnoActual+1);
                        }
                    }else{
                        puntos[turnoActual] -= 2;
                        errores++;
                        System.out.println("No se encontro, hay: " + errores);
                        turnoActual++;
                        if( turnoActual == numJugadores ){
                            turnoActual = 0;
                        }
                        for( int i = 0; i < numJugadores; i++ ){
                            salida[i].println("I " + letra + " " + turnoActual+1);
                        }
                    }
                   
                    System.out.println("Turno ahora es: " + turnoActual );
                }
            }
            if( errores == 10 ){
                for( int i = 0; i < numJugadores; i++ ){
                    salida[i].println("P " + puntos[i] );
                }
            }else{
                int max = -1;
                int posicion = -1;
                for( int i = 0; i < numJugadores; i++ ){
                    if( puntos[i] > max ){
                        max = puntos[i];
                        posicion = i;
                    }
                }
                for( int i = 0; i < numJugadores; i++ ){
                    if( i == posicion ){
                        salida[i].println("G " + puntos[i] );
                    }else{
                        salida[i].println("P " + puntos[i] );
                    }
                }
            }
           
           
        } catch (IOException ex) {
            Logger.getLogger(ServidorJuego.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}