Per fer-ho senzillament hem d'escriure:

sudo apt-get install tomcat6
cd /usr/share/tomcat6
sudo ln -s /var/lib/tomcat6/conf conf
sudo ln -s /etc/tomcat6/policy.d/03catalina.policy conf/catalina.policy
sudo ln -s /var/log/tomcat6 log
sudo chmod -R 777 /usr/share/tomcat6/conf

Llavors només queda que al definir el nostre servidor a l'Eclipse li donem la ruta /var/lib/tomcat i ja podem començar el nostre projecte.

#!/bin/bash
for i in `find *.tpl -type f -print`;
do
iconv -f ISO-8859-1 -t UTF-8 $i -o $i.new;
mv -f $i.new $i;
done

Primerament hem de carregar les capçalera per a poder emprar les funcions md5 d'openssl:

#include <openssl/md5.h>

Amb això podem cridar a les funcions MD5_Init, MD5_Update i MD5_Final. Com indica el nom MD5_Init serveix per iniciar el procés de conversió, inicialitzant una variable del tipus MD5_CTX. Per a l'exemple l'anomenarem state:

MD5_CTX state;

MD5_Update requereix 3 paràmetres. Primerament la nostra variable state, per a seguir i actualitzar el context de les dades de les que crear-ne el MD5. Segon li hem de passar una dada de tipus unsigned char, en el nostre cas anomenada buffer. Aquesta variable el que conté són les dades de les que volem que faci el MD5. Com que el buffer és una estructura dinàmica, el tercer paràmetre és un enter indicant el nombre de caràcters que ha de llegir.

unsigned char *buffer;
int comptador;

Cal tenir en compte que MD5_Update es pot cridar tantes vegades com faci falta fins a carregar totes les dades dessitjades.

Per acabar emprem la funció MD5_Final, que de primer paràmetre ens demana una cadena unsigned char, de 16 bytes, que serà el que es coneix com a digest (la variable l'anomenarem així), que és el MD5 en format binari. Com a darrer paràmetre l'hi passem la variable state, que conté el context del que s'ha de generar el MD5.

unsigned char *digest;

Tot aquest procés ens dona el digest, que és un valor binari. Però el problema és que podem voler tractar el md5 de forma visual, en format de cadena, llegible per a una persona. Per fer això ens podem fer una petita funció a mà.

char *digestAMD5(unsigned char *digest)
{
  static const char HEX_DIGITS[] = "0123456789abcdef";
  char *md5;
  int n;
 
  md5=malloc(sizeof(char)*33);
  for (n = 0; n < 16; n++)
  {
    md5[2*n]   = HEX_DIGITS[(digest[n] >> 4) & 0x0f];
    md5[2*n+1] = HEX_DIGITS[digest[n] & 0xf];
  }
  md5[32] = 0;
 
  return (char *) md5;
}

Aquesta funció ens generaria un MD5 legible per a una persona. Un exemple per veure-ho funcionant tot junt:

#include <openssl/md5.h>
int main()
{
  unsigned char *buffer, *digest;
  int comptador;
  char *md5;
  MD5_CTX state;
 
  //Demanem memòria per a les nostres cadenes
  digest=malloc(sizeof(char)*16);
  md5=malloc(sizeof(char)*33); //El md5 és de 32 caràcters, en posem un més per poder-hi afegir el byte de fi de cadena.
 
  //Carreguem el buffer del lloc que necessitem
  //Això ja depen d'on extrequi cadascú la informació de la que vol fer-ne el md5
 
  //Inicialitzem el entorn
  MD5_Init(&state);
 
  //Afegim les dades del buffer. Es pot anar cridant aquesta funció les vegades que faci falta
  MD5_Update(&state, buffer, comptador);
 
  //Genera el digest de les dades enviades. Recordem que no poden ser visualitzades per una persona
  MD5_Final(digest, &state);
 
  //Generem una cadena amb el MD5, ara sí, en format llegible per a una persona
  md5=digestAMD5(digest);
 
  //Afegir caràcter de fi de cadena per a que el printf ens mostri correctament la nostra cadena
  md5[32]='\0';
  printf("El MD5 val: %s", md5);
  return 0;
}

Sembla i és una tonteria, però m'hi he trencat les banyes un parell de dies per a poder-ho fer servir...

Així que m'he posat a remenar per a trobar com dir-li que em completés el codi automàticament. Per fer-ho he anat al menú Projecte->Opcions de Projecte. Allí he anat al Suport de C++ i he marcat la casella Automatic code completion a la pestanya Code completion. Això activa la autocompletació de codi, però encara no en té idea de les llibreries de qt. Per a afegir el suport per a les QT a la mateixa pestanya busquem el quadre Base de dades per al completat de codi i premem el botó afegeix.

En el meu cas he triat Importador de PCS de Qt4 per a KDevelop i llavors he especificat la ruta a les meves llibreries de qt4 ( /usr/include/qt4 , en el meu cas). Ha estat una estona fent la base de dades i ja he tingut la autocompletació de codi activada!!

Així que m'he posat a fer pràctiques de codi a sac. Entre elles es troba la d'ASO (Administració de Sistemes Operatius), que té com a pràctica muntar un linux (kernel inclòs) amb gestió d'usuaris mitjançant ldap, servidor apache, repositòri subversion i que sigui capaç d'administrar tots els processos i l'ordinador mitjançant comandes de bash que són cridades via una plana web.

Com que consta d'uns quants passos i s'ha de documentar per a fer la memòria he pensat fer-ho aquí i així ja tenir-ho pas per pas i només haver de fer un copy&paste a la memòria

Ja que s'ha de compilar el kernel i així, he tirat pel recte i he agafat gentoo (on la seva guia per aquests temes és molt detallada, i fàcil de seguir).

En breu la configuració del kernel per a la meva màquina, que ja quasibé està acabat (falta pulir el wifi), així com els passos a seguir per fer-ne la instal·lació mínima.

El problema és que està a ~x86, però és fàcil de solucionar.

Primer és fer que ens deixi compilar aquesta versió. Obrim l'arxiu /etc/portage/package.keywords i afegim el següent:

dev-util/codeblocks

I ara ja podem compilar el code:blocs amb:

emerge codeblocs

També ens farà falta el sdcc:

emerge sdcc

Ara que ja tenim tot el necessari, obrim el code:blocs, no patiu si us diu que no detecta el compilador sdcc, ja ho arreglarem.

Li donem a crear projecte i triem "Empty Project". Triem quin nom li volem donar al projecte i on el volem guardar. Al següent pas hem de triar quin compilador volem emprar, en aquest cas sdcc. Quan creem el projecte es queixarà de que no sap els flags d'optimització del compilador, ni cas.

A anem a "Settings" i triem el submenú "Compiler and Debugger". De la llista triem el sdcc i sel·leccionem la pestanya "Toolchain executables". Veurem que està definida a /usr/local/bin, quan a gentoo s'intal·la a /usr/bin, així que ho canviarem per /usr/bin. A la pestanya "Compiler Settings" buscarem "[CPU] Microchip PIC 14-bit ..." i ho marcarem.

Veurem que a la pestanya "Compiler Settings" hi ha una altre pestanya dintre, "Other options", la marcarem i dintre hi escriurem el xip per al que compilem, per exemple:

-p16f876a

Ja li podrem donar a acceptar. Per a comprovar que tot funciona correctament, creem un arxiu .c al projecte i hi posem el següent:

 
#include
<pic16f876a.h>
 
int main()
{
    return 0;
}
 

I fem un build. Si no dona cap error, ja li podem donar canya a la programació de pics

Tot i així no l'he pogut provar ja que la PIC de proves semblava estar tarada.

El cas és que demanant informació a ARDE sobre el tema dels compiladors existents, sobretot un capaç de suportar codi cpp, em van recomanar fer una ullada a Port de GCC a PIC16 i això vaig fer.Aquí l'autor ha escrit el codi necessari per a que puguem compilar els nostres programes en c per a PICs de la família 16 amb gcc. A la espera de provar algun experiment amb cpp, direm que només suporta c, doncs l'autor m'ha dit que manquen llibreries encara per a que això sigui possible.

Aquí explico el procés que he seguit per a compilar el gcc sense trepitjar-ne la versió que ja en tenia.

Primerament ens descarregarem i instalarem el gputils disponible a la nostra distribució. En gentoo:

emerge gputils

Un cop instal·lat gputils crearem una nova carpeta (suposaré que la carpeta està a Documents). A dintre hi descarregarem la versió de gcc 4.0.2 i la 1.0.0 de csl-pic-gcc i els descomprimirem:

mkdir gccpic
cd gccpic
wget  ftp://ftp.gnu.org/gnu/gcc/gcc-4.0.2/gcc-4.0.2.tar.bz2
wget  https://forja.rediris.es/frs/download.php/324/csl-pic-gcc-16f877-1.0.0.tar.gz
tar xfvj gcc-4.0.2.tar.bz2
tar xfvz csl-pic-gcc-16f877-1.0.0.tar.gz

Ara haurem de configurar el fitxer pic.h per a indicar-li correctament l'ubicació de les eines de gputils (si compilem el paquet 'oficial' en comptes del de la nostra distribució, aquest pas no fa falta).

vim gcc-4.0.2/gcc/config/pic/pic.h

On canviarem les línies

#define DEFAULT_ASSEMBLER "/usr/local/bin/gpasm"
#define DEFAULT_LINKER "/usr/local/bin/gplink"

per

#define DEFAULT_ASSEMBLER "/usr/bin/gpasm"
#define DEFAULT_LINKER "/usr/bin/gplink"

Ara crearem la carpeta on anirà la nostra versió de gcc:

mkdir pic-gcc
cd pic-gcc

I executarem el configure i en compilarem el codi:

../gcc-4.0.2/configure -target=pic -enable-languages=c,c++
make

Ja tenim els binaris creats a la carpeta gcc, però ara volem que sigui més fàcil emprar-los, per això farem un parell d'enllaços simbòlics, com a root s'ha de fer (poso el meu directori de home com a exemple, s'ha de canviar a la ruta correcte al vostre sistema):

su
(introduim la clau)
cd /usr/bin
ln -s  /home/mad93/Documents/gccpic/pic-gcc/gcc/g++ picg++
ln -s /home/mad93/Documents/gccpic/pic-gcc/gcc/xgcc picgcc

I ja podrem compilar els nostres programes amb picgcc i picg++. Vull recordar que cpp encara no es pot emprar per certa mancança de llibreries, però ho deixo aquí així esperant que en un futur pròxim ja sigui possible.

Es pot pensar que php és molt potent i versàtil, de fet, ho és. Així doncs, perquè canviar a Rails?

Personalment el que més m'ha atret de rails és el seu model MVC, on M ve de Model (taula de la base de dades), V de View (vista, del codi a mostrar per pantalla, templates) i C de Controller (codi pròpiament dit on s'executen les instruccions abans de ser enviades al template).

Perquè és important aquesta separació? Doncs només heu d'haver fet una o dues webs per saber que si es fa una cosa gaire gran i no es guarda un ordre acuradament, el codi es torna enrevessat i difícil de seguir. Amb rails també ens pot passar, però és més difícil per com està estructurat tot.

El funcionament és senzill, quan es demana una plana web el controlador mira quina acció ha de realitzar en funció de l'adreça entrada, n'executa el codi interactuant amb els models per aconseguir les dades necessàries i finalment passa les variables a View per a que generi la sortida pel navegador.

Altre característica interessant de rails, és que té moltes accions predefinides i comportaments 'preestablerts'. Així doncs, amb aquestes convencions ens estalviem un munt de codi.

Com podeu haver suposat ja, Ruby on Rails, està escrit en ruby, un llenguatge d'scripting amb unes regles més pròximes a perl i python, que no pas a php i per tant, a C.

Altre diferència de php i rails, és que php és un llenguatge, i rails és un framework (entorn de treball). Això fa que disposem de moltes eines per a fer més ràpid, fàcil i netament el nostre codi (no sempre és així, però la majoria de vegades sí).

Personalment, penso que en termes generals, php és més potent i versàtil que rails, i tot i que aquest darrer no para d'evolucionar, per segons quines aplicacions ens pot seguir interessant treballar amb php. Altrament, si volem fer una plana web, amb les opcions més típiques, rails sense dubte és una molt bona alternativa.

He fet poca cosa amb rails pel moment, bé, s'han deixat un parell de projectes a mig fer, a l'espera de saber-ne més per aplicar-ho correctament quan els coneixements fossin prou profunds. De moment la única plana que puc mostrar-ne és la web del fansub d'Animelliure, feta en rails i amb un sistema, casolà, de diferents versions de la web (skins).

Espero fer un parell d'entrades explicant una mica en més profunditat com funciona rails, doncs és molt interessant.

Un clar exemple d'això és quan volem emprar models i controladors en català en una aplicació corrent sota rails, intenta convertir els noms al singular/plural, però, és clar, a la versió anglesa.Una manera de solucionar això és és emprar inflect. inflect ens permet redifinir els canvis de singular-plural, plural-singular 'màgics' que fa rails. Per a modificar els termes que vulguem només hem d'anar a l'arxiu config/enviroment.rb i al final afegir-hi:

Inflector.inflections do |inflect|
inflect.singular("noticies","noticia")
inflect.plural("noticia","noticies")
end

Com podeu veure, primer hem definit el singular de notícies i després el plural de notícia. També podem emprar inflect.uncountable amb el terme que no volem que canviï de singular a plural i viceversa.

Així doncs he decidit revisar el codi d'un joc força senzill que vaig fer per la gp2x i fer el que s'anomenaria una demo, un programa que no fa res de res ><

En aquest programa només es carrega una imatge i una cançó i es surt amb la tecla "return". Per limitacions de coneixements i per no complicar molt la cosa, la resolució és fixa a 1024x768 (SDL_Image no té una funció per reescalar les imatges o.O).

El programa intenta explicar-se per si mateix, però bé, com que són comentaris per a mi, no sé si explica prou bé que es fa a cada pas, aquí el codi:

#include <stdio.h>
#include <stdlib.h>
 
#include <SDL.h>
#include <SDL_mixer.h>
#include <SDL_image.h>
#include <time.h>
 
int main(int argc, char *argv[])
{
//Definim la variable pantalla
SDL_Surface *pantalla;
int sortir=0;
//Inicialitzem el SDL
if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) &lt; 0)
{
//Entro si peta al inicialitzar el SDL
fprintf(stderr, "Incapaç d'inicialitzar SDL: %s\n", SDL_GetError());
exit(1);
}
//Fixem la mida de la pantalla
pantalla= SDL_SetVideoMode(1024,768,16,SDL_DOUBLEBUF | SDL_FULLSCREEN);
if (!pantalla)
{
//Mostrem l'error
fprintf(stderr, "No s'ha pogut establir el mode de vídeo: %s\n", SDL_GetError());
exit(1);
}
//Ara tenim el mode de vídeo activat i podem començar a fer coses
 
//Carreguem al buffer de pantalla una imatge
SDL_Surface *imatge;
imatge=IMG_Load("prova.jpg");
 
//La passo a pantalla
SDL_BlitSurface(imatge, NULL, pantalla, NULL);
//Mostro per pantalla la variable pantalla
SDL_Flip(pantalla);
 
//Poso música
int audio_rate = 22050;
Uint16 audio_format = AUDIO_S16SYS;
int audio_channels = 2;
int audio_buffers = 4096;
 
if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers) != 0) {
fprintf(stderr, "No s'ha pogut inicialitzar l'audio: %s\n", Mix_GetError());
exit(1);
}
 
//Carreguem el ogg
Mix_Music *musica;
musica = Mix_LoadMUS("musica.ogg");
if(musica == NULL)
{
fprintf(stderr, "Incapaç de carregar el ogg: %s\n", Mix_GetError());
exit(1);
}
//Fem el bucle infinit amb -1
if(Mix_PlayMusic(musica, -1) == -1)
{
fprintf(stderr, "Incapaç d'obrir l'arxiu ogg: %s\n", Mix_GetError());
exit(1);
}
 
//Pengem el programa fins que hi hagi un event de teclat
while (!sortir)
{
SDL_Event event;
SDL_WaitEvent(&amp;event);
if(event.key.keysym.sym==SDLK_RETURN)
{
sortir=1;
}
}
//Matem el SDL
SDL_Quit();
}

I ja tenim un programa cutrillo que fa ús de pantalla completa i de música (està en loop).

Aquí en teniu una versió compilada per a x86 i amb els arxius necessaris (imatge i música), així com el codi font (Del Makefile ni cas, que ara no recordo com fer-lo ).