Instalar Windows 7 (Seven) o vista desde el USB

He creado un simple manual de como Instalar Windows 7 (Seven) o Vista desde un USB para portátiles  que no dispongan de lector óptico. Posteriormente lo completaré con otro manual que explica como instalar Windows Seven en un Disco duro virtual VHD, que viene a ser un fichero en el disco duro. De esta manera podemos usar Windows 7 sin tener que crear ninguna particion extra, simplemente es un fichero en la carpeta de nuestro disco. Lo tengo instalado así y el rendimiento es sorprendente, mucho mejor que en una máquina virtual obviamente. La verdad que funciona muy bien. Veremos cuando se lance la RC1 que está al caer las nuevas funcionalidades que aporta.

La dirección de descarga es esta

Noticia Interesante

Leído en La Vanguardia y el Periódico de Catalunya.

En la vanguardia es del dia 20 de Noviembre en la edición impresa.

TITULACIONES DE INFORMÁTICA
Exclusión injusta
Francesc Roca Tugas
Viladecans

Si voy a una farmacia y compro paracetamol para mi dolor de cabeza, ¿soy médico? ¿Soy ya un farmacéutico? Si monto una pared de pladur en mi casa, ¿soy arquitecto? Si configuro mi teléfono móvil para navegar por internet, ¿soy ingeniero en telecomunicaciones?

El informático no es el que instala Windows. Eso lo hace un niño de ocho años. El informático fue el que consiguió que ese niño pudiera hacerlo. En ingeniería informática no existe la asignatura de Windows, Word, Excel… Existen asignaturas como Diseño de Bases de Datos, que no es ni mucho menos hacer un documento Access; Administración o Diseño de Sistemas Operativos, que no es instalar Windows; Ingeniería del Software, que no es aprender un simple lenguaje de programación cualquiera y tirarse a hacer un programa para venderlo al primero que pase.

Significa saber especificar una necesidad, diseñar un sistema de información que la resuelva, diseñar cada uno de los componentes que van a ser necesarios, evaluar alternativas de desarrollo, programarlos, integrarlos, probarlos, medir su rendimiento, ponerlos en explotación, proponer su plan de seguridad, su plan de contingencias ante incidencias, salvaguardar sus datos, prever los cambios de explotación futuros… Y todo ello utilizando tecnologías no obsoletas y estándares de desarrollo.

Si alguien tiene alguna duda de que las ingenierías en informática tienen o no contenido propio, simplemente ojeen los contenidos de los planes de estudio de las diferentes titulaciones oficiales. Percibirán que algo no se está comprendiendo bien por parte de nuestro Gobierno cuando nos ha excluido de las titulaciones propuestas para el ejercicio de profesiones de ingeniero.

 

Aquí está el texto original en La Vanguardia y en El periódico de Catalunya

Introducción a IP

Como prometí antes del verano quería hacer una entrada sobre el ccna. Bién aún la tengo pendiente, pero de mientras os dejo unas 20 y pico transparencias sobre el protocolo IPv4 y IPv6.

Estan orientadas para gente con poco conocimiento técnico del protocolo, de manera que sean entendibles por todo el mundo.

Son mis primeras trasparencias hechas en LaTeX, concretamente usando Beamer, creo que han quedado bastante bién. Las podéis descargar en el apartado de descargas de la web o adjuntas a este mensaje.

Cualquie error que veáis, me lo podéis comunicar por mail y lo intentaré arreglar lo antes posible. Si alguien quiere los ficheros fuente .tex que me las pida y se las envío.

Compilando un compilador en antlr

Compilando un compilador de Java

Introducción.

Haciendo una práctica de la universidad en PCCTS, nos tocaba implementar un compilador con todas sus fases. Análisis sintáctico, léxico, semántico, y la generación de código. (La parte de optimización de código solo se daba a nivel teórico). Usábamos árboles AST (Abstract Syntax Tree) para guardar los datos y las estructuras intermedias que íbamos generando.

Aquí os presentaré una versión muy simplificada para los que alguna vez os habéis preguntado como implementar un compilador. De echo la implementación que haré aquí namás reconocerá expresiones muy básicas como sumas y restas. Y también asignaciones. Así nos evitaremos muchos problemas que tendríamos si aceptáramos funciones, procedimientos, declaracion de tipos estructurados, paso de parámetros por valor o referencia …

La herramienta que usaremos se llama ANTLR, que es la versión actualizada de PCCTS y esta, es basada en java en lugar de C++.

El tutorial está basado en la versión 3.0 de antlr. Es una versión nueva con cambios significativos respecto a la versión 2.X, pero mejor empezar con una versión que tenga más recorrido.

Introducción.

Haciendo una práctica de la universidad en PCCTS, nos tocaba implementar un compilador con todas sus fases. Análisis sintáctico, léxico, semántico, y la generación de código. (La parte de optimización de código solo se daba a nivel teórico). Usábamos árboles AST (Abstract Syntax Tree) para guardar los datos y las estructuras intermedias que íbamos generando.

Aquí os presentaré una versión muy simplificada para los que alguna vez os habéis preguntado como implementar un compilador. De echo la implementación que haré aquí namás reconocerá expresiones muy básicas como sumas y restas. Y también asignaciones. Así nos evitaremos muchos problemas que tendríamos si aceptáramos funciones, procedimientos, declaracion de tipos estructurados, paso de parámetros por valor o referencia …

La herramienta que usaremos se llama ANTLR, que es la versión actualizada de PCCTS y esta, es basada en java en lugar de C++.

El tutorial está basado en la versión 3.0 de antlr. Es una versión nueva con cambios significativos respecto a la versión 2.X, pero mejor empezar con una versión que tenga más recorrido.

A parte de antlr necesitaremos un programa para diseñar la gramática. Optaremos por ANTLRWorks. Lo podemos descargar aquí: http://antlr.org/works/index.html

Con este .jar ya tenemos también antlr ya que viene incluido dentro del paquete. Hay que tener presente que necesitamos también tener la máquina de java instalada en nuestro pc.

Una vez descargado, damos doble click y debería arrancar el programa. Sino desde la consola con:  java –jar Nombredelfichero.jar

Ahora ya estamos en disposición de empezar a diseñar la gramática.

 

Pasos previos.

Bien, antes de empezar a diseñar nuestra gramática, os explicaré un poco la estructura de un fichero .g o gramática de antlr.

Para arrancar nuestro compilador, dado que usamos java y todo se traducirá a este lenguaje podemos optar por meter todo el código del compilador dentro del fichero .g en el sitio que pertoque o escribirlo en ficheros aparte. Si lo hacemos en ficheros aparte deberemos compilar desde la línea de comandos todos los .java que hayamos añadido. Como lo que quiero es hacerlo entendible, escribiremos todo el código en un solo fichero.

Con esto conseguiremos que desde ANTLRWorks podamos generar todos los ficheros .java y arrancar una línea de comandos con nuestro compilador.

La estructura del fichero de gramática es la siguiente:

grammar SimpleCalc;

 

tokens {

PLUS     = ‘+’ ;

MINUS = ‘-‘ ;

}

 

@members {

public static void main(String[] args) throws Exception {

SimpleCalcLexer lex = new SimpleCalcLexer(new ANTLRFileStream(args[0]));

CommonTokenStream tokens = new CommonTokenStream(lex);

SimpleCalcParser parser = new SimpleCalcParser(tokens);

try {

parser.expr();

} catch (RecognitionException e)  {

e.printStackTrace();

}

}

}

 

/*——————————————————————

* PARSER RULES

*——————————————————————*/

expr      : ID ‘=’ op {System.out.println($ID.text +”=”+ $op.value);};

op          returns [int value]

:   e=factor {$value = $e.value;}

(   PLUS e=factor {$value += $e.value;}

|   MINUS e=factor {$value -= $e.value;}

)*

;

factor    returns [int value]

: NUMBER {$value = Integer.parseInt($NUMBER.text);};

 

/*——————————————————————

* LEXER RULES

*——————————————————————*/

 

ID  :   (‘a’..’z’|’A’..’Z’)+ ;

NUMBER             : (DIGIT)+ ;

WHITESPACE : ( ‘t’ | ‘ ‘ | ‘r’ | ‘n’| ‘u000C’ )+   { $channel = HIDDEN; } ;

fragment DIGIT                : ‘0’..’9′ ;

Bueno como seguramente pensaréis, esta es la gramática que he usaré para el ejemplo. De hecho no la he diseñado yo. Es muy parecida a una que hay en los ejemplos de la página de antlr aquí: http://www.antlr.org/wiki/display/ANTLR3/Five+minute+introduction+to+ANTLR+3 o bien aquí: http://www.antlr.org/wiki/display/ANTLR3/Expression+evaluator

 

He sombreado los bloques para que se vean las partes diferenciadas del fichero.

La primera parte es la cabecera del fichero. Aquí hemos de prestar atención de darle el mismo nombre que tiene el fichero. ¿Os recuerda a java esto, no? Pues básicamente la idea es la misma. La clase debe llamarse igual que el nombre del fichero, sino, no compilará.

El segundo bloque es la declaración de tokens. Aquí debemos añadir todos los elementos que queremos que reconozca nuestra gramática. En nuestro caso el signo + y el signo –

El tercer bloque @ members contiene el código java de nuestra aplicación. En nuestro caso hemos colocado un main. De hecho el programa funcionará igual sin este código el problema es que no podremos llegar a ver nada si el texto de entrada es aceptado. Lo que hace este código es leer un fichero de texto especificado en la línea de comandos cuando arrancamos nuestro compilador, eso es args[0]. Dentro del bloque try, llamamos a la primera regla del programa (parser.expr()), esto desencadenará el inicio del programa.

El cuarto bloque es las reglas del parser, es decir puramente la gramática. Aquí podemos ver como una expresión es un ID (identificador, o nombre de variable) el token igual ´=´ (si, ya sé que lo podríamos haber definido en el apartado de tokens, pero para que vierais que también podemos ponerlo directamente aquí) y una operación (la definimos más abajo). Lo que vemos entre { } es el código java que he escrito yo. Basicamente nos imprimirá por pantalla las expresiones que vaya reconociendo.
La siguiente regla es la operación. Tenemos un factor OPERANDO factor. El factor en nuestro caso será un entero, lo podemos ver en la tercera regla. Lo que hace es almacenar en una variable valor temporal, el resultado de sumar o restar los dos factores.
La tercera regla, almacena en una variable llamada value el resultado de parsear la lectura del fichero a un Entero.

El cuarto bloque es la declaración de los tipos en nuestro caso un ID (identificador de variable) es cualquier nombre de la a-Z que contenga al menos una letra. Esto es debido a la cláusula positiva de Klenee (+).
El mismo razonamiento para los números, para los espacios en blanco y los dígitos.

Me he dejando por comentar un par de cosas adrede, porque quería que quedaran claras. Los campos disponen de varios valores (como si fueran una struct) estos son .value y .text.

Se entiende que value es un entero y text un campo para almacenar strings, como los ID.

Generando código y compilando.

El siguiente paso es generar el código del parser y del lexer, es decir, de la parte del compilador que se encargará de leer la entrada y mirar que sea correcta a nivel sintáctico, y el lexer que es el encargado de realizar las operaciones y comprobar que todo funcione correctamente.

Para generar el código de ambos, en el ANTLRWorks, vamos a Generate à Generate Code.
Esto nos creará dos ficheros java que hemos de compilar.

El siguiente paso como he dicho es compilar el programa. Para ello abrimos una consola y escribimos:

javac SimpleCalcLexer.java SimpleCalcParser.java

Si todo ello funciona correctamente, como debería, nos generará dos ficheros class con el mismo nombre que los java. Podemos arrancar nuestro compilador con:

java SimpleCalcparser test.txt

El fichero test.txt lo he creado yo con un editor de texto. Simplemente se trata del fichero de nuestro programa. En mi caso lo que he escrito es:

A=3+6

Y el resultado de la ejecución del programa es:

A=9

Por tanto, como podemos comprobar ha realizado correctamente la operación.

Probando el compilador.

Vamos a probar de toquetear un poco nuestro programa. Primero de todo intentamos ver que pasa si cambiamos en nuestro fichero de código nuestra asignación por esta otra:

A=3+v

Rápidamente nuestro compilador se quejará y nos dará un error como este:


Como podemos ver se queja de que no reconoce el token v en esa expresión. Es decir un error de missmatch o sea que no coincide lo que espera con lo que le llega. Obvio ya que hemos definido las sumas como sumas de enteros y v no es ningún entero, ya que es un ID.

Otras cosas curiosas que podemos observar, aparte de lo limitado que es para el reconocimiento de expresiones, es que el programa no tiene memoria. Si os fijáis en el código lo veréis. No os preguntáis ¿donde se almacena el valor de nuestros cálculos?
Si miráis otra vez el código veréis que el proceso que hacemos cada vez que se encuentra una expresión bien formada (entiéndase por una expresión correctamente aceptada) es simplemente imprimirla por pantalla. No guardamos ningún registro de ella.

Esto tiene fácil solución.  Veremos cómo arreglar estos problemillas y completar un poco nuestro rudimentario compilador.

Mirando más allá.

Como hemos comentado antes, queremos mejorar nuestro compilador para que, además de guardar un registro de nuestras asignaciones, nos permita incorporar sumas de variables (ID) declaradas en nuestro programa.

El primer paso será guardar el valor de una asignación. Es necesario para el siguiente paso, ya que si queremos usarla más tarde, primero la hemos de tener grabada. ¿Lógico no?

Antes de nada, vamos a modificar la gramática para que nos admita mas de una asignación. Si os fijáis la regla expr, nuestra primera regla silo reconoce una expresión. Para ello cambiaremos el nombre de expr por asig y antes de esta regla añadiremos una nueva regla llamada expr.

El código será algo así:

Con esto ya habremos conseguido reconocer un conjunto de 1…* asignaciones.

Para guardar las variables usaremos una tabla Hash. Java ya nos proporciona una estructura de datos de este tipo. Se llama HashMap.

En la directiva @members debemos añadir nuestra estructura. Quedaría algo así:

HashMap variables = new HashMap();

Hemos de importar ahora la clase HashMap. Para esto antlr dispone de un nuevo espacio para indicar los imports de clases java. Añadiremos el siguiente código justo antes de la directiva @members

@header {

import java.util.HashMap;

}

 

Con este cambio, solo nos faltará modificar las reglas de la gramática. En concreto, la regla asig, aparte de que nos muestre la asignación aceptada, haremos que nos guarde el resultado en la tabla de variables. Dentro del código java entre llaves, añadimos el siguiente:

asig    : ID ‘=’ op {System.out.println($ID.text +”=”+ $op.value); variables.put($ID.text, new Integer($op.value));};

 

Como veis hemos añadido una instrucción para que nos añada en la tabla la variable, con su valor entero.

Si probáis de ejecutar el código no veréis ningún cambio, salvo que en el main imprimáis la tabla hash.

El siguiente paso es modificar la regla factor para que nos permita operar también con variables (ID).

factor  returns [int value]

:   NUMBER {$value = Integer.parseInt($NUMBER.text);}

|   ID

{

Integer v = (Integer)variables.get($ID.text);

if ( v!=null ) $value = v.intValue();

        else System.err.println(“Variable no definida: “+$ID.text);

        };

Si observáis hemos añadido una regla nueva con una disyunción (|). Esta regla busca la variable ID, en la tabla de variables, la parsea a un entero. Si no la encuentra imprime un mensaje de error “Variable no definida”.

Para probarlo usaré este juego de pruebas simple:

v=7+2

a=3+v

 

El resultado debería ser V=9 y a=12. Veamos si es correcto:

Pues funciona perfectamente. Vamos a probar ahora de añadir una variable que no exista. Cambiamos el juego de pruebas anterior por este:

v=7+2

a=3+vr

Y vemos como el resultado no es satisfactorio:

Si os fijáis la ultima suma sí que se realiza, pero la variable inexistente se toma como valor = 0.

Esto lo podríamos cambiar con un simple ajuste en el código que trata la variable no encontrada.

Ampliaciones.

Bien, hasta aquí ya tenemos algo más presentable. Ahora podríamos mejorarlo añadiendo la generación de un árbol AST y recorriéndolo, con lo que podríamos hacer lo mismo que hemos hecho pero más aproximado a lo que hace un compilador real.

Se puede seguir ampliando con más operaciones. Podéis probar de añadir otras operaciones de enteros, como multiplicación, división.

El siguiente paso sería añadir algún nuevo tipo. Podríamos añadir tipos de coma flotante, pero ya se complicaría mucho más, ya que deberíamos mostrar errores cuando intentáramos dejar el resultado real en un entero, es decir no admitir la pérdida de precisión.

Otra ampliación interesante podría ser añadir el tipo booleano. Esto nos permitiría añadir las operaciones boleanas AND, OR, NOT, y también añadir algunas mas expresiones enteras que tienen resultados booleanos, como la IGUALDAD, MAYOR, MENOR, MENOR IGUAL, MAYOR IGUAL, DIFERENTE…

De hecho no sería necesario añadir el tipo booleano para jugar con estas expresiones. Podríamos usar el 0 entero como el falso y el 1 por ejemplo como cierto.

Los últimos pasos ya serían la declaración de tipos estructurados, añadir soporte para declaración y uso de funciones y sus correspondientes paso por valor, referencia…

Resaltado con Geshi

Usando GeSHi para resaltar código

En Este artículo os voy a explicar como podemos hacer para resaltar nuestro código fuente con una libreria php muy simple de usar. Además de ser muy intuitiva los resultados estan muy conseguidos. De echo es uno de los sistemas más usados en la actualizadad y casi todos los CMStienen plugins que permiten usar GeSHi

Pincha en leer mas para leer el artículo completo

Usando GeSHi para resaltar código

En Este artículo os voy a explicar como podemos hacer para resaltar nuestro código fuente con una libreria php muy simple de usar. Además de ser muy intuitiva los resultados estan muy conseguidos. De echo es uno de los sistemas más usados en la actualizadad y casi todos los CMStienen plugins que permiten usar GeSHi

Pincha en leer mas para leer el artículo completo

Descargando e Instalando Geshi

Para empezar a usar GeSHi hemos de descargar el código y la librería de la página web oficial. La página oficial del proyecto es esta:  http://qbnz.com/highlighter/ Una vez descargamos el código, creamos una nueva carpeta en nuestro servidor y lo descomprimimos allí dentro. La estructura debería ser la siguiente: En nuestra carpeta deberíamos tener el fichero geshi.php que es la librería, y tres carpetas más. Estas son contrib, una carpeta con ejemplos “ready to run”, otra llamada docs con documentos de ayuda y documentación del proyecto y otra llamada geshi que es la que contiene los parsers para cada uno de los lenguajes que soporta GeSHi.Para hacer este ejemplo, nosotros crearemos un nuevo fichero en la raíz de esta carpeta, es decir junto con el fichero geshi.php donde es visible todas las carpetas de geshi comentadas anteriormente.

El primer intento de resaltado

Una vez realizado el paso anterior podemos proceder a intentar nuestro primer resaltado. La idea es hacer una especie de “hola mundo” pero con GeSHi. Así que lo más fácil que podemos hacer es intentar resaltar un trozo de código fácil, como por ejemplo podría ser una definición y una asignación de variables. En nuestro fichero recién creado y dentro de los tags de php debemos poner la siguiente línea: require $path . ‘geshi.php’; Con esto estaremos diciéndole a php donde ir a buscar las funciones de GeSHi, es decir estamos habilitando el uso de esas librerías.Ahora, lo primero que hemos de hacer para empezar a entendernos con GeSHi, es crear un objeto de GeSHi. Este tiene una función creadora, que requiere dos (o tres) parámetros: El primer parámetro es una string con el código que queremos resaltar. El segundo parámetro es una string que indica con que lenguaje de programación queremos resaltarlo, y el tercero y último, es opcional para especificar la ruta a el idioma en caso que no esté en la carpeta de idiomas de GeSHi. En nuestro caso usaremos los que ya vienen. Los podéis consultar en la carpeta geshi que hemos copiado antes.El segundo parámetro, el del lenguaje de programación, tiene que coincidir con el nombre del fichero del lenguaje de GeSHi, asi que hemos de llevar cuidado.En nuestro caso probaremos de resaltar el siguiente código java:

int number;
boolean yes;
number=5;
yes=false;

Para ello escribiremos el siguiente código:

require  . 'geshi.php';
$codigo="int number;
boolean yes;
number=5;
yes=true;";
$lenguaje="java";
$migeshi= & new GeSHi($codigo,$lenguaje);
echo $migeshi->parse_code();

$codigo tiene el trozo de código que queremos resaltar. Para que sea correcto el resaltado debe ser un código correcto en el lenguaje que queremos usar.$lenguaje es una string con el lenguaje que queremos aplicar el resaltado.$migeshi es una variable para guardar el objeto de geshi. Le pasamos a la creadora los dos parámetros, como hemos comentado anteriormente.Por último un echo para ver el código resaltado en el navegador. Notad que hemos de llamar a la función parse_code() que es la que nos devuelve el código resaltado.

Si todo ha ido correctamente el resultado debería ser el siguiente:

int number;
boolean yes;
number=5;
yes=false;

Probamos ahora con C++. Solo hemos de cambiar la palabra boolean por bool y donde seleccionamos el lenguaje poner cpp en lugar de java. El código sería algo así:

require  . 'geshi.php';
$codigo="int number;
bool yes;
number=5;
yes=true;";
$lenguaje="cpp";
$migeshi= & new GeSHi($codigo,$lenguaje);
echo $migeshi->parse_code();

Y el resultado:

int number;
bool yes;
number=5;
yes=true;

Entrando más a fondo

Para entrar más a fondo podemos consultar el fichero geshi.php y observar que funciones nos ofrece GeSHi para mejorar aún más la presentación. $geshi->enable_classes();Nos permitirá activar la salida en CSS. $geshi->enable_line_numbers(GESHI_NORMAL_LINE_NUMBERS);Esta llamada nos activará el número de línea delante de cada línea de código. Hemos elegido la constante GESHI_NORMAL_LINE_NUMBERS, pero podríamos seleccionar también GESHI_FANCY_LINE_NUMBERS para activar el otro estilo de números. Para más información, se puede consultar el fichero example.php en la carpeta contrib.

Primeros pasos con Google App Engine


Primeros pasos con Google App Engine

¿Qué es Google App Engine?

Google App Engine es un servicio de creación y publicación de aplicaciones web de google. Con Google App Engine podemos crear aplicaciones web en python, usando el framework que nos proporciona google y adem´s podemos publicarlas en la web. El framework es muy poderoso y además, nos permite usar un lenguaje de bases de datos, llamado GQL, muy similar a SQL, con lo cual aún se amplian mas las posibilidades.

Haz click en leer mas para ver la noticia entera.

Primeros pasos con Google App Engine

¿Qué es Google App Engine?

Google App Engine es un servicio de creación y publicación de aplicaciones web de google. Con Google App Engine podemos crear aplicaciones web en python, usando el framework que nos proporciona google y adem´s podemos publicarlas en la web. El framework es muy poderoso y además, nos permite usar un lenguaje de bases de datos, llamado GQL, muy similar a SQL, con lo cual aún se amplian mas las posibilidades.

Haz click en leer mas para ver la noticia entera.

¿Cómo crear una aplicacion web en google?

Con esta entrada quiero explicaros como crear una aplicación en los servidores de google usando una herramienta llamada Google App Engine.

Lo primero de todo, debemos descargarnos el SDK de Google App Engine aquí: http://code.google.com/p/googleappengine/

Este framework requiere tener instalado python 2.5 o superior. El propio instalador te dice donde descargarlo.

Lo siguiente, crear una cuenta de Google App Engine. Lo podemos hacer aquí: http://appengine.google.com/

Una vez dentro rellenamos los datos que nos pide incluido el nombre del dominio de nuestra aplicación. Bien, ya estamos listos para iniciar nuestra aplicación.

 

Creamos una carpeta en nuestro disco duro, en nuestro caso, llamada helloworld.

Dentro de esta carpeta creamos dos ficheros. El primero, se llamará helloworld.py. Lo que haremos será escribir nuestro código python aquí.

En nuestro caso imprimiremos por pantalla un helloworld, con lo cual el código es el siguiente:

 print 'Content-Type: text/plain' print '' print 'Hello, world!'

El siguiente fichero, es el fichero de configuración. Se llamara app.yaml. Lo rellenaremos con esto:

 

application: helloworld

version: 1

runtime: python

api_version: 1

handlers:

– url: /.*

script: helloworld.py

 

La primera línea es el nombre de la aplicación.

La segunda la versión de nuestra aplicación.

La tercera el lenguaje de programación que hemos usado para escribirla (de momento solo soporta python)

La cuarta, la versión de la api, por el momento uno.

 

En el apartado handlers, en el campo url hemos de decirle que peticiones aceptamos. Es una expresión regular, que por defecto lo aceptará todo. Por último decirle el fichero donde tenemos nuestra aplicación.

 

Con esto ya tenemos nuestra aplicación lista. Ahora podemos ejecutar el webserver que lleva el SDK integrado. Para arrancar nuestra aplicación escribimos en una consola:

dev_appserver.py directorio

Donde directorio es donde tenemos los ficheros de nuestra aplicación. Por ejemplo: dev_appserver.py C:helloworld

 

Ahora, podemos abrir la siguiente dirección en nuestro navegador y veremos nuestra aplicación:

http://localhost:8080

 

Si todo ha ido bién, deberiamos ver el mensaje:

Hello, world!

 

Subir la aplicación a google.

Para poder subir la aplicación a google debemos darle un nombre que elegimos al registrar. En mi caso el nombre fue albertnoguescom. Por tanto cogemos el script anterior, cambiamos el nombre de directorio a albertnoguescom, el fichero .py, también le ponemos de nombre albertnoguescom.py, y por último editamos el fichero app.yaml.

En este caso debemos cambiar las líneas para que sean igual que las siguientes:

application: albertnoguescom

script: albertnoguescom.py

 

Para subir la aplicación al servidor, escribimos en la consola:

appcfg.py update C:albertnoguescom

 

Nos pedirá nuestro mail en gmail y nuestro password. Solo la primera versión.

Pues, se acabó. Ya tenemos disponible nuestra aplicación. Podemos probarla en la dirección:

http://albertnoguescom.appspot.com/

 

Cada vez que se ejecuta este comando, la versión sube en 0.1. Empieza en 1, 1.1, 1.2… Este control de versiones nos permite volver a una versión antigua en caso de error.

En próximos capítulos veremos cómo usar formularios, bases de datos y recuperar versiones antiguas de nuestra aplicación en caso de error.

Nuevos formatos de office en offices anteriores a 2007

Trabajando con Office 2007

Si no os acaba de dar el peso el nuevo office 2007, ya bien porque no os acostumbráis a las nuevas posiciones de las funcionalidades, o bién lo de trabajar sin menús no os gusta, hay varias alternativas disponibles.

1. Usar un programa que nos añada una barra con el típico menou de office de toda la vida. si optamos por esta opción tenemos disponibles varios programas. los mas usados son, entre ellos estos dos:

Classic Menu for Office 2007 de AddinTools

ToolbarToggle

Ambos programas son de pago. Si alguien conoce algun programa gratuito que haga lo mismo que me avise y lo añadiré a la lista.

2. Seguir usando office 2003 y bajar de la web de microsoft un addin para nuestra versión que permite cargar y exportar documentos en formato 2007 de office. El addin a instalar se puede descargar de manera gratuita aquí.

Los formatos de archivo del nuevo office, si bién complican la compatibilidad con otras aplicaciones como open office, si consiguen tener un tamaño de archivo bastante menor, debido a que son ficheros zip, con código xml dentro de el, por lo tanto un formato docx no es lo mismo que el antiguo formato doc, sino que basicamente es un archivo zip que contiene una serie de documentos xml que contienen el texto, imágenes y demas que forman parte del documento, asi como toda la série de estilos y demás que hayamos aplicado a nuestro documento. en definitiva docx es el formato Office Open XML.

Para la gente interesada en saber mas sobre los nuevos formatos de office, pueden consultar este mensaje (en inglés).

Obteniendo datos de Last.fm con php

Obteniendo datos de Last.fm con php

He escrito una miniguia para conectarse a los webservices de Last.fm y poder recoger información nuestra como por ejemplo la lista de temas preferidos, las canciones mas escuchadas, y muchas cosas mas. Para ello usaremos php.

En un script de 7 linias podremos conectarnos al webservice y recoger los datos y hacer un echo para mostrarlo por pantalla.

Haz click en leer mas si quieres verlo.

PD: Hay un Tutorial Mejorado y Ampliado en el blog de Carlos Martínez aquí

Obteniendo datos de Last.fm con php

He escrito una miniguia para conectarse a los webservices de Last.fm y poder recoger información nuestra como por ejemplo la lista de temas preferidos, las canciones mas escuchadas, y muchas cosas mas. Para ello usaremos php.

En un script de 7 linias podremos conectarnos al webservice y recoger los datos y hacer un echo para mostrarlo por pantalla.

Haz click en leer mas si quieres verlo.

PD: Hay un Tutorial Mejorado y Ampliado en el blog de Carlos Martínez aquí

 

Obteniendo datos de Last.fm con php

El objetivo de esta mini guía, es como obtener datos del webservice de Last.fm y poderlos mostrar en nuestra web.
Hay varias maneras de obtener esos datos. Dado que podemos conectarnos a un webservice, cualquier implementación de por ejemplo, xmlrpc nos bastará. Las tenemos en c, en java, php… casi cualquier lenguaje imaginable.
En esta guía usaremos php ya que es el lenguaje orientado a webs más usado. Más adelante haré una versión java, pero ya veréis como no cambia mucho.

¿Qué necesitamos?

Empecemos

Lo primero de todo será decidir que webservices nos interesan. Vamos a la web y miramos información sobre ellos.
En este caso he decidido hacerlo sobre la lista de 10 pistas reproducidas últimamente. Seleccionamos el Plain Text como marca la flecha y se nos mostrará una web con las últimas 10 canciones escuchadas. Ahora deberemos parsear esa información en el código php y la tendremos lista para mostrarla.

Seleccion del Webservice

Perfecto, vamos al código

".str_replace("?","-",$vectorPista[1])."";
}
?>

Como podemos ver el código es bastante simple.
Definimos el usuario del que queremos obtener los datos. Este usuario obviamente ha de estar registrado en Last.fm, en caso contrario no nos devolverá nada. (Bueno si, una página de error).

Usaremos get_file_contents que es una función incorporada de php para obtener el contenido de un fichero. Si os fijáis esta dirección coincide con la que os comentaba anteriormente, la que hemos obtenido antes, simplemente cambiando el usuario por defecto que es “RJ” por el nuestro, fijado en la variable usuario.

Obtenemos la codificación en UTF-8 de la string que hemos conseguido antes. Esto evitará que nos salgan caracteres ilegibles.

Partimos las líneas del fichero por el carácter de salto de línea “n”. Esto nos devolverá en $pista un vector con 10 Strings que serán nuestras canciones.

Hacemos un recorrido sobre cada una de las 10 Strings del vector. La estructura de cada línea es como la siguiente:

   1209158147,Travis  ? All I Want to Do Is Rock

Es decir tenemos un timestamp, separado por una coma el intérprete y separado de un interrogante la canción. Como el interrogante queda feo, lo cambiaremos por un guión.

Ahora lo primero es partir esta cadena de teto en dos más, Partiremos por la coma, de manera que tendremos en $vectorPista[0] la primera parte de la cadena, antes de la coma, es decir el timestamp y en $vectorPista[1] el autor y el titulo.

   $vectorPista[0] = 209158147
$vectorPista[1] = Travis ? All I Want to Do Is Rock

Por supuesto obviaremos la primera parte, ya que no nos interesa.

Por último cogeremos la parte que nos interesa, es decir $vectorPista[1] y reemplazaremos el carácter “?” por un “-“. Esto lo hacemos con la función de php str_replace. El primer parámetro es el carácter a buscar, el segundo es el nuevo carácter, y el tercer parámetro es donde hemos de hacer la sustitución, en nuestro caso en la cadena $vectorPista[1].

Pues ahora tan solo queda mostrarlo en pantalla. Esta con un tag HTML <li> que es una lista de tal manera que salgan como si fuera un índice con el carácter · delante.

El resultado es el siguiente:

 

Resultado