Aquests dies estic començant a mirar-me tot el tema d’Android i per sort meva tenen un document, que per a mi, és molt important: Application Fundamentals.

Allà no t’explica cap truc per fer que la teva aplicació sigui perfecta, ni tan sols t’explica com l’has d’estructurar, però en canvi et vomita totes les paraulotes de la terminologia que es fa servir a Android. Per exemple: no fas crides a classes per crear una nova pantalla, sinó que fas un Intent. Totes les necessitats de hardware i software externs al teu projecte han d’estar escrits en un fitxer xml…

Evidentment llegint això no serveix per crear aplicacions, però sense llegir-ho ho passaràs força malament

Alguns consells sobre què més llegir o quines pàgines consultar per quan hi hagin dubtes sobre Android?

Avui m’he posat a instal·lar tot el necessari per començar a desenvolupar sobre Android¹ i com que s’ha d’instal·lar unes quantes coses, és aquí una llista ràpida sobre què i en quin moment:

• Instal·leu el Java JDK6
• Instal·leu l’Eclipse 3.5
• Baixeu i instal·leu l’SDK de l’Android
• Instal·lar el connector ADT per l’Eclipse i configureu-lo

Amb això i seguint les notes d’inici ràpid del lloc de desenvolupadors d’Android ja podreu començar a crear projectes i programar

1. Consells, enllaços i tot el que us sembli que em pugui ajudar és benvingut! [↩]

Llegint la documentació del JHBuild¹ he vist que pots mirar les dependències que tenen cada programa des del propi terminal o generar un gràfic que ho mostri, per exemple les dependències de l’Epiphany són:

Resulta que aquest gràfic tant ben fet es fa amb un llenguatge de programació anomenat DOT. La sintaxi és ben senzilla i la facilitat de creació de gràfics és impresionant (només cal mirar els exemples de la Wikipedia).

La genialitat de la implementació que en fa el Graphviz és que no només et treu .jpg o .png sinó que a més a més et pot treure .svg de manera que amb dos minuts pot definir el gràfic amb llenguatge DOT i després et pots estar l’estona que faci falta retocant-lo amb l’Inkscape.

Em sembla que a partir d’ara quan hagi de fer gràfics obriré el terminal en comptes d’un editor d’imatges o de vectors

1. Programa per a compilar el GNOME des dels dipòsits de codi font [↩]

Com que a la nova feina faig de programador des de fa dies que estic consultant una pàgina web que suposo que ja deu ser força coneguda:

• http://stackoverflow.com/

És un web que et permet fer preguntes, etiquetar-les i respondre’n. La interfície realment és molt senzilla i és molt còmode utilitzar-la¹

Fa pocs dies que a més vaig descobrir que tenen una versió del web pensada per a administradors:

• http://serverfault.com/

Igual com la primera també molt molt útil (tot i que amb menys volum pel que sembla de moment).

1. A diferència de molts webs anomenats 2.0 que sembla més que el seu objectiu sigui entrar a una galeria d’art més que no pas utilitzar-se [↩]

Quan portes setmanes darrere un error que no hi ha manera racional d’explicar-lo i després d’un intensiu des de les 7 de la tarda a pràcticament les 12 de la nit (uff són unes 5 hores!) però l’acabes resolent … uff no té preu!

Això sí, ha sigut difícil trobar-lo el c*** quan per fi l’he trobat tenir obertes 12 terminals, diferents instàncies del Meld, uns quants Gedit, a saber quantíssimes pàgines web (amb l’Epiphany òbviament , etc etc

Com podeu veure que he posat el logo de l’empresa on treballo és un programa que estic fent per l’empresa i que gràcies a que ja (per fi!!) he trobat aquest bug aviat (espero) podrà veure la llum el què he estat fent

Nota no relacionada en absolut: Intenteu no barrejar programar en C i amb Python, us oblidareu TOTS els punt i coma del final de sentències a C i haureu de recompilar com 12 vegades per tonteries per l’estil

Per tenir les dades que genera una aplicació que estic fent amb Python he escrit un parell de funcions que em permeten tenir un document estructurat (en xml) de totes les dades que es generen[1].

La tècnica de introspecció es basa en aprofitar les meta-dades (per dir-ho d’alguna manera) que tens sobre els objectes que has anat construint en l’aplicació per (dinàmicament) poder-ho formatar d’alguna manera.

Amb Python tenim algunes propietats, com molt bé es descriuen en un article d’IBM [2]:

• objecte.__dict__ : Ens retorna una llista amb els elements que formen part de l’objecte. Així per mostrar els elements faríem:

for element in objecte__dict__:
print “%s val %s” % (element, objecte.__dict__[element])

• Si volem refinar el que volem mostrar tenim tot un seguit de funcions que ens diuen quin tipus de variable estem tractant: les comparacions amb el comparador is (exemple: if x is dict ….) per als tipus bàsics, callable per saber si és tracta d’un mètode, i per a objectes i classes isinstance(objecte, classe-o-llista-de-classes) i issubclass(classe, info-de-classe).

Només amb això podem treure molt suc a la informació que tenim ara mateix a les estructures de dades que estem muntant i si es fa el més genèric possible, no caldrà tocar ni una coma quan afegim més dades o hi encadenem alguna altra estructura.

[1] En certa manera hi ha truc perquè el sistema són classes que tenen diccionaris de classes a dintre fins a 5 nivells de manera que la introspecció és recursiva per naturalesa.

[2] És una mica vell, del 2002, però pels meus objectius n’he tingut ben prou

Per pas d’arguments s’entén que quan crides una funció li dius amb quins valors vols que faci la seva funció.

Per exemple:

suma(3,4) # retorna 7
suma(4,5) # retorna 9

El problema pot passar (com m’acabo de trobar i solucionar) en que si haig de passar força arguments (6 en concret) i a més els haig de redirigir es fa pesat mantenir les llistes d’arguments sincronitzades, per exemple si tenim un parell de classes que una hereda (Secundaria) de l’altre (Principal) i volem cridar el constructor de Principal des del constructor de Secundaria haurem de fer una cosa per l’estil:

class Principal():
def __init__(self, primer, segon, tercer, quart, cinquè, sisé):
/* … operem amb ells …*/
class Secundaria (Principal):
def __init__(self, primer, segon, tercer, quart, cinquè, sisé):
Principal.__init__(primer, segon, tercert, quart, cinquè, sisé)

Per a simplificar-ho Python ens permet diverses coses:

• valors predeterminats: Si sabem que un valor serà gairebé sempre el mateix i en contades vegades un de diferent podem fer que sigui opcional donant-li un valor des de la declaració de la funció

def taula_multiplicar(base, inici=0, final=10): # declarem una funció amb 3 paràmetres dos dels quals ja tenen un valor assignat
taula_multiplicar(3) # ens mostraria la taula de multiplicar del 3 des de 3*0 fins a 3*10, la típica de l’escola
taula_multiplicar(4, 5) # ens mostraria la taula del 4 des del 5 fins al 10
taula_multiplicar(4, 9, 12) # ens mostraria la taula del 4 des del 9 fins al 12

• llista d’arguments: Si no sabem quants arguments (o no ens importa) podem dir que els agafi tots

def crea_directoris(*directoris): # declarem una funció que agafa tots els arguments que li passen i els posa en una llista (tupla en Python)
crea_directoris(‘/home/gil’, ‘/home/silvia’, ‘/home/softcatala’, ‘/home/gnome’ # ens crearia els 4 directoris que li passem
llista = ( ‘/home/gil’, ‘/home/silvia’ # creem una llista amb els arguments
crea_directoris(*llista) # passem la llista enlloc de tot el text en la crida, li indiquem que es una llista amb el símbol *

• diccionari d’arguments: Si el que volem es enviar les dades però no ens recordem de l’ordre en que estan posats en la declaració (per exemple si fem taula_multiplicar(3,5,7) però volíem la taula del 7 del 3 al 5 ens trobarem amb la taula del 3 del 5 al 7) podem fer servir els noms dels arguments

taula_multiplicar(inici=3, final=5, base=7) # ara ja tindrem la taula de multiplicar del 7 des del 3 al 5def parelles(**valors): # declarem una funció en que rebrem parelles de valors
parelles(un=1, dos=2, tres=3) # passem parelles de paràmetres amb nom amb el seus valors
diccionari = { ‘un’: 1 , ‘dos’: 2, ‘tres’: 3} # creem un diccionari
parelles(**diccionari) # enlloc d’haver-ho de posar tot en la crida a la funció creem un diccionari abans i ho indiquem en la crida amb els dos * (igual com en el pas per llista)

També es poden fer coses més sofisticades i complicades com barrejar llistes, diccionaris, valors predeterminats i paràmetres normals, per exemple:

def funcio_estranya( valor_posicional, valor_predeterminat=5, *resta_arguments): # amb aixo creem una funció que el primer paràmetre es un de normal, després en bé un d’opcional i la resta hauran de ser una llista d’arguments variable

No està malament eh

Aquest tros de codi amb Python:

#!/usr/bin/env python
# -*- encoding: utf-8 -*-

class main():
   def laptop(self):
      self.p()

class one(main):
   def p(self):
      print "Lenovo"

class two(main):
   def p(self):
      print "Asus"

# Creem un parell d'instàncies
i_one = one()
i_two = two()

i_one.laptop() # mostra "Lenovo"
i_two.laptop() # mostra "Asus"

El que fa bàsicament és crear 3 classes (dues d’elles -one i two- hereden de la primera -main-) de manera que totes les instàncies que es facin de les classes filles tindran els mètodes de la classe mare (el mètode laptop en aquest cas).

A més cada classe filla defineix una mateixa funció (la funció p).

La gràcia d’aquest disseny és que et permet definir una especialització de comportament de manera que per exemple, si tens una col·lecció d’instàncies de one i two barrejades però vols saber-ne quin portàtil tenen, només cal que executis el mètode laptop a tota la col·lecció que sense cap problema ens dirà per a cada un d’ells quin portàtil té.

El dubte que em queda ara és: quin nom rep aquesta tècnica? Perquè he estat buscant en el llibre de Python que tinc (Learning Python d’O’Reilly) d’on he recordat aquesta possibilitat del Python i no he aconseguit trobar-la ni a l’índex del principi (per temes) ni  el del final (per nom).

En el servidor executeu:

repositori=NOM_PROJECTE

svnadmin create /var/svn/repos/$repositori
chown -R apache:svnusers /var/svn/repos/$repositori
chown -R g-w /var/svn/repos/$repositori
chown -R g+rw /var/svn/repos/$repositori/db
chown -R g+rw /var/svn/repos/$repositori/locks

En el client (per ssh) [1]:

svn import -m"comentari"  FITXERS_A_IMPORTAR svn+ssh://USUARI@MÀQUINA/var/svn/repos/$repositori

En el client (per http) [2]:

svn import -m"comentari" FITXERS_A_IMPORTAR http://MÀQUINA/svn/$repositori

[1] [2] Evidentment, s’ha de configurar tant l’ssh com l’apache perquè ho permetin

després de dinar no sabia què fer i m’ha picat el cuc hacker i m’he decidit a tancar el l’errada #106779

moltes, moltes, moltes hores després he aconseguit que totes les peces encaixin i ara per fi ja he pogut enviar un pedaç que afegeix la funcionalitat d’amagar o mostrar les traduccions que ja estan al 100%

per fer-lo m’he basat en l’enllaç que hi havia en l’últim comentari de l’errada, però el problema era que no s’havia de commutar un o tots els elements de les llistes, sinó que uns i prou

de manera que m’he tirat dels cabells navegant per Internet fins que he trobat una manera fàcil i còmode:

• primer de tot es defineix un identificador a cada una de les dues taules (la de documentació i la de interfície gràfica [1])
• seguidament a partir d’aquests identificadors agafes els elements tr d’aquestes taules i els passes per un bucle
• en el bucle l’únic que has de fer es comprovar si tenen un identificador que acabi amb -complete[2] i si es dóna el cas fer un (obj).style.display = ‘none’ o (obj).style.display = ”
• evidentment, perquè això funcioni, fa falta posar-hi els identificadors quan es generen les pàgines

tot i que és molt millorable, si s’aplica aviat i es posa en els servidor en producció (el l10n.gnome.org) anirà que ni pintat ara que ja falta menys d’un mes per al llançament del GNOME 2.22

[1] realment no caldria fer-ho així i es podria fer directament amb tot el document de cop, però com que les pàgines son prou grosses així la consulta al DOM es més curta

[2] i això és possible gràcies a que disposem d’expressions regulars a Javascript!