Mudanza

Me fui para http://slecorp.wordpress.com/ solo por dos una razones... no encontré una app para android que deje publicar directamente a blogger y ya tenia este blog con algunos temas que pueden fusionarse en uno solo.

Nos vemos al otro lado

Volviendo a Linux

 

Hace un tiempo había cambiado el Ubuntu 11.10 a windows xp, esperando que fuese mas rápido, pero con un portátil de 1Gb de Ram y un Celeron a 1Ghz (o 1.2 no me acuerdo), después de instalar todas las aplicaciones necesarias, este se puso mas lento que el mismo Ubuntu, así que se me dio por pasarlo a windows 7, (también me habían dicho que era mas eficiente con los recursos…) pero al final siguió igual de lento; así que espere a que saliera Ubuntu 12.04 LTS (LTS significa Long Term Support, es decir, una versión con soporte de larga duración), pero esta vez no me aventure a instalar Ubuntu con unity, sino que baje Kubuntu, y hasta ahora esta corriendo fluido, incluso sin instalarle el paquete “kubuntu-low-fat-settings” el cual cambia la configuración de KDE para hacerlo mas liviano; hice esta prueba cuando tenia Ubuntu 11.10 con escritorio KDE, funcionó a la perfección,  el escritorio es mas liviano para equipos viejitos; pero la recomendación es si van a usar KDE instalen Kubuntu, ahorran espacio y velocidad.

Aun así, estoy pensando en aumentar la memoria, igual el nuevo kernel trae soporte PAE de serie.

PD: Escrito desde Windows Live Writter en la pc del trabajo… si alguien sabe de alguna para Linux con conexión a blogger por favor escribirla en los comentarios.

Encabezado Fijo ( con jquery )

Anteriormente había escrito un articulo sobre como mantener el encabezado fijo en el un tabla html con css; ahora he encontrado un plugin de jquery que permite hacerlo de forma mas facil:

1. Se descarga de: http://www.tablefixedheader.com/download/
2. Se vincula en la pagina donde esta la tabla que vas a fijar el encabezado: <script src="/js/jquery.fixheadertable.min.js" type="text/javascript"></script>
3.  Se llama al plugin con los siguientes parametros:



$('#miTabla').fixheadertable({
caption : 'Titulo de la tabla',
colratio     : [80, 90, 90, 90], // medidas del ancho de cada columna
resizeCol         : true,  // se puede cambiar el tamaño de la columna
minColWidth : 80 ,
height   : 400,
showhide       : true // esto es para ocultar o mostrar los datos con un clic
});

y listo... encabezado fijo.

Ley Lleras

Preocupante...

Pilas C++ !!

Pilas en C++:
Hace poco me llego una "barbacha" (Barbacha: dicese del trabajo freelance, pequeño, temporal en donde el precio es mas regateado que una película en San Bazar..), esta consistía en realizar un programa en C++ que determinara si una palabra es palindrome (palabra que se lee igual al derecho y al revés).
Para desarrollarlo use code::blocks (http://www.codeblocks.org/), un ide para C++ que me ha parecido excelente, ademas de ser multiplataforma.

Una pila es un tipo especial de lista enlazada de la cual solo se puede insertar y eliminar elementos en uno de los extremos de la lista. Imaginemos una lista enlazada como un tren, en donde cada vagón lleva su carga y tiene un enlace al siguiente vagón. Por lo tanto un nodo de la lista tendria un campo de valor y en C++ un puntero hacia el siguiente nodo(vagón).



class nodo{
// metodos publicos: son los que se acceden desde otros objetos
    public:
// inicializamos el constructor del objeto
        nodo(char v, nodo *sig = NULL){
            valor = v;
            siguiente = sig;
        }
    private:
        char valor; // el dato que guardamos en el nodo
        nodo *siguiente; // puntero hacia el siguiente nodo


    friend class pila; // definimos que la clase pila tiene acceso a los metodos
};


typedef nodo *pnodo; // definimos un tipo de dato


Estos nodos irían encapsulados en una clase llamada pila, que es la encargada de aplicar la lógica de sacar y meter datos. Esta clase deberá llevar un contador para saber cuando la pila esta vacia, con el fin de evitar punteros a campos nulos,


/*
Definimos la clase pila que manejara los metodos de sacar y meter
nodos dentro de la pila
*/
class pila{
    public:
        pila() : ultimo(NULL){ contador=0;}
        ~pila();


        void Push(char v); // con Push se ingresa un nuevo nodo con valor
        char Pop(); // con Pop se extrae el ultimo nodo ingresado
        int contador; // contador nos permite determinar si la pila esta vacia o
 // todavia tiene algun dato


    private:
        pnodo ultimo; // nodo que nos indica cual es el ultimo de la pila
};

Para insertar un valor usamos la función Agregar(char), esta funciona de la siguiente manera:

1. Incrementamos el contador al crear un nodo
2. Recibimos el valor por parámetro
3. Guardamos el nuevo nodo como el ultimo de la pila.

void pila::Agregar(char v){

    this->contador++;

    pnodo nuevo;

    // crea nodo nuevo

    nuevo = new nodo(v, ultimo);

    // apuntar el comienzo de la pila alnuevo nodo

    ultimo = nuevo;

    if(!primero) primero = nuevo;

}

Para sacar un valor usamos la función Leer, esta funciona así:

1. Decrementamos el contador de items
2. Creamos un nodo auxiliar y una variable para retornar el valor del nodo que vamos a sacar
3. Guardamos el ultimo nodo en el nodo auxiliar
4. En el ultimo nodo, guardamos el siguiente del auxiliar
5. Guardamos en la variable el valor del nodo actual
6. Borramos el nodo con la función delete
7. Retornamos el valor del nuevo nodo

char pila::Leer(){
    this->contador--;
    pnodo nodo; // variable auxiliar para manupular el nodo
    char v; // variable auxiliar para retorno
    if(!ultimo) return ' '; // si no hay nodos retorna vacio
    //el nodo apunta al primer elemento de la pila
    nodo = ultimo;
    // asignamos a pila toda la pila menos el primero
    ultimo = nodo->siguiente;
    //guardar el valor a retornar
    v = nodo->valor;
    delete nodo;


// si la cola quedo vacia, el ultimo debe ser NULL tambien
    if (!primero) ultimo = NULL;


    return v;
}


El destructor en C++ es una función que se encarga de limpiar la memoria del sistema cuando el objeto ya no se va a utilizar. Lo único que hace es recorrer toda la lista e ir borrando item por item.


/*
El destructor sirve para finalizar el objeto pila
recorre cada item de la pila y lo elimina con delete
*/
pila::~pila(){
    pnodo aux;


    while(ultimo){
        aux = ultimo;
        ultimo = ultimo->siguiente;
        delete aux;
    }
}

Ahora la lógica para determinar si una palabra es palindrome es sencilla, solamente tienes que comparar la primera letra con la ultima y así sucesivamente hasta comprobar toda la palabra letra por letra. Si alguna letra es diferente a su equivalente ya no es una palindrome.


int main(){


    cola Cola;
char palabra[256];
int i =0;
int longitud = 0;
bool palindrome = true;


cout << "Digite la palabra" << endl;
cin >> palabra;


/*
La idea es ingresar la palabra a la pila, despues recorrer el vector
que contiene la palabra de forma inversa comparandola con la pila
de forma normal; asi comparamos el ultimo termino de la palabra en
el vector contra el primer termino de la pila.
Si llega a existir alguna letra diferente, ya no es palindrome
*/


for (i=0; palabra[i] != '.'; i++){
Cola.Agregar(palabra[i]);
longitud++;
}


for (i=longitud-1; i>0; i--){
char caracter;
char caracter_pila;
caracter = palabra[i];
caracter_pila = Cola.Leer();
if (caracter != caracter_pila || caracter == ' '){
palindrome = false;
break;
}
}
if (palindrome){
        cout << " Es palindrome" << endl;
}else{
        cout << " No es palindrome" << endl;
}


    return 0;
}


No es el mejor algoritmo, pero es para aprender Pilas, ademas mi lenguaje es Java, y este ya trae estas funciones y estructuras de serie. C++ también con templates, pero es un lenguaje que hasta ahora estoy tomando en serio.
Se reciben comentarios de optimizacion y correcciones.

Fuente:
http://c.conclase.net/edd/index.php?cap=002#inicio

Comprimir en linux [Terminal]

Estoy usando Ubuntu 11.10, vengo usándolo desde la 10.04, y lo cambie porque cuando compre mi portátil Vostro 1500 venia solamente con 1Gb de Ram y la tortura de Windows Vista, con ese sistema operativo y esa memoria solamente podía ejecutar notepad, y eso que parte se va para la virtual... pero en otra entrada daré mi análisis sobre esta versión de Ubuntu, por ahora voy a colocar como comprimir desde linux. Creo que esto aplica a casi todas las distribuciones. 


Es interesante ver cual es el mejor comprimiendo una carpeta de 450 megas entre archivos comprimidos, paginas jsp, js, imagenes, y clases:


Para comprimir un directorio en (*.tar.gz):
Comprimir: tar -cvf archivo.tar.gz /directorio/
Descomprimir: tar -xvf archivo.tar.gz

-c : indica a tar que cree un archivo.

-v : indica a tar que muestre lo que va empaquetando.

-f : indica a tar que el siguiente argumento es el nombre del archivo comprimido

-x : indica a tar que descomprima

Tamaño comprimido: 254.243.613 bytes




Comprimir y empaquetar archivo o directorio en (*.tar.bz2)
Comprimir: tar -c directorio | bzip2 > archivo.tar.bz2
Descomprimir: bzip2 -dc archivo.tar.bz2 | tar -xv
Tamaño comprimido: 242.879.874


Comprimir y empaquetar archivo o directorio  en (*.zip)
Comprimir: zip archivo.zip directorio
Descomprimir: unzip archivo.zip
Tamaño comprimido: 259.243.905


Comprimir y empaquetar archivo o directorio  en (*.lha)
Comprimir: lha -a archivo.lha directorio
Descomprimir: lha -x archivo.lha
Tamaño comprimido: 256.172.988


Comprimir y empaquetar archivo o directorio  en (*.arj)
Comprimir: arj a -r archivo.arj directorio
Descomprimir: arj -x archivo.arj
Tamaño comprimido: 257.450.957


Comprimir y empaquetar archivo en (*.rar)
Comprimir: rar -r archivo.rar directorio
Descomprimir: rar -x archivo.rar

Tamaño comprimido: 253.781.737

Cargue de un archivo a FTP con Java

Continuando con el tema de FTP y Java tratado en el articulo anterior, ahora vamos a cargar un archivo al FTP con la misma librería commons.net


try {
String ls_directorio = "archivos";
ftp.connect(IP_FTP);
if (!ps_usuario.equals("") && !ps_password.equals("")){
ftp.login(USUARIO_FTP, PASSWORD_FTP);
respuesta = ftp.getReplyCode();
if (respuesta == 230){
ftp.setFileType(FTP.BINARY_FILE_TYPE);
ftp.changeWorkingDirectory(ls_directorio);
respuesta = ftp.getReplyCode();
if (FTPReply.isPositiveCompletion(respuesta) ){
File archivo = new File("Ruta del archivo a cargar");
boolean ret_cargue = ftp.storeFile(archivo.getName(), new FileInputStream(archivo));
b_retorno = ret_cargue;
}
}
}
} catch (Exception ex) {

} finally {
try {
ftp.disconnect();
} catch (IOException ex) {
}
}

He agregado varias comprobaciones, como que la contraseña no sea vacia y dos especiales :


respuesta = ftp.getReplyCode();
if (respuesta == 230){


esta significa que pudo hacer login en el servidor y:



ftp.changeWorkingDirectory(ls_directorio);
respuesta = ftp.getReplyCode();
if (FTPReply.isPositiveCompletion(respuesta) ){



Significa que pudo cambiar de directorio dentro del servidor. La comprobación de cambio de directorio no necesita de un codigo porque ya esta parametrizado dentro de la clase FTPReply en isPositiveCompletion