Blog

Search by tag: guida

oracolo google

Ogni mattina un navigatore si sveglia e invia una query sbagliata a Google, ottenendo come risultato una pagina pescata randomicamente nell’universo delle pagine web.

Ogni mattina un webmaster si sveglia e, guardando le statistiche del proprio sito, si domanda cosa diavolo passa per la testa dei navigatori quando devono cercare qualcosa su Google.

Non importa che tu sia un navigatore o un webmaster, o entrambi… l’importante è ricordarsi che da qualche parte nel mondo c’è qualcuno che osserva le minchiate che fai! :P


E’ ora di dire basta a questo scempio…

… vediamo di far chiarezza sul modo corretto di porre le domande all’*Oracolo* :)

Qualche consiglio:

  1. Non scrivere domande come se Google fosse una persona, ma focalizzare il problema ed estrapolare delle parole chiave.
    es: affitti case palermo

  2. Utilizzare la logica! Esistono degli operatori logici che permettono di legare diversamente i termini di ricerca, in modo + completo rispetto al semplice spazio.
    Gli operatori logici disponibili sono AND, OR, – (NOT)
    es: affitti AND (case OR appartamenti OR monolocali) AND (palermo OR monreale)

  3. Utilizzare l’*asterisco* come carattere jolly.
    es: “c’era una * un gatto”

  4. Google tende ad inserire nella ricerca anche le parole simili a quella cercata (singolare/plurale, maschile/femminile). Per forzare la ricerca alla parola esatta, inserire un segno più (+) prima della parola (attaccato alla parola).

  5. Analogamente, per forzare la ricerca alle parole simili (come i sinonimi), inserire il segno tilde (˜) prima della parola.

  6. Cercare di capire, a seconda del contesto, se è più opportuno cercare contenuti in lingua inglese. Per problemi di origine informatica è praticamente indispensabile (ma bisogna anche capire cosa c’è scritto nelle pagine trovate)!

  7. Analizzare il problema per trovare delle “frasi tipiche” o termini specifici che aiuterebbero il motore di ricerca ad isolare le pagine più adatte. E’ il caso dei messaggi di errore dei programmi, che devono essere riportati ESATTAMENTE come vengono letti (è meglio un copia&incolla, quando possibile).
    es: java.lang.UnsatisfiedLinkError: sublime.so: wrong ELF class: ELFCLASS32 (Possible cause: architecture word width mismatch)

  8. Utilizzare le “virgolette” per cercare una frase intera invece che le singole parole. Utile, per esempio, se si cerca il testo di una canzone di cui non si conosce il titolo.
    es: “and it’s hard to hold a candle in the cold november rain”

  9. Utilizzare i comandi speciali di Google per concentrare la ricerca sugli URL (inurl:), sui titoli delle pagine (intitle:), sul corpo delle pagine (intext:), cercare all’interno di siti specifici (site:), cercare i collegamenti ad un sito o ad una pagina (link:), oppure cercare solo file con una certa estensione (filetype:), opzione utile per la ricerca delle immagini (per esempio, io cerco sempre immagini con estensione .png).

Un esempio concreto: voglio cercare tutte le pagine che contengono il mio nome, escludendo le pagine del mio sito. Inoltre, visto che c’è un tizio francese di Pézénas (non è chiaro dove siano gli accenti) che è un mio omonimo, vorrei escludere anche le pagine che parlano di lui.

Scriverò nel campo di ricerca di Google questa query:

("bruno mendola" OR "mendola bruno") -site:brunomendola.net -~pézénas

Adesso procediamo al contrario: quelle che seguono sono alcune query digitate da navigatori che in qualche modo sono approdati nel mio blog…

  1. mi si rifiuta l’iscrizione a my space perchè?
    sarebbe stato più giusto qualcosa del genere: myspace “iscrizione rifiutata”

  2. Java Micro Edition dove lo posso scaricare
    di sicuro avrebbe trovato subito quello che cercava digitando j2me download

  3. che alimenti devono evitare se sono allergica al solfato di nichel… bastava scrivere allergia “nichel solfato” alimenti per trovare una tabellina molto esplicativa

  4. errore compilatore netbeans impostare ruby interpreter, in questo caso il navigatore avrebbe dovuto inserire la stringa ESATTA dell’errore, non una parafrasi italianizzata!

  5. che programma devo scaricare per un programmatore con porta seriale, anche in questo caso una terminologia più adeguata non avrebbe guastato: software “programmatore seriale”… la soluzione sta nel primo risultato.


In conclusione: non penso proprio che questo post mi toglierà il divertimento di aprire le statistiche degli accessi al mio sito! :)


In ogni grande azienda, quando si tratta di adottare una nuova tecnologia, ci si trova sempre frenati da qualcuno che pone la domanda “e con tutto il software sviluppato finora che facciamo?”.
In effetti è vero che non si può pretendere di fare il porting di tutto il codice già scritto ogni volta che viene scoperto un nuovo framework di programmazione.

interoperabilityLa soluzione sono i Web Services, “un sistema software progettato per supportare l’interoperabilità tra diversi elaboratori su di una medesima rete” (fonte: Wikipedia).

Il Web Services Description Language (WSDL) è uno standard internazionale, promosso dal World Wide Web Consortium (W3C), che permette la descrizione delle caratteristiche di un Web Service attraverso uno schema XML/SOAP, il quale viene utilizzato come “strumento di sincronizzazione” tra il framework fornitore del servizio e quello che sarà l’utilizzatore (che, grazie a questa forma di comunicazione standard, potranno anche essere basati su linguaggi di programmazione eterogenei).
Grazie al WSDL è possibile, per esempio, utilizzare un’infrastruttura software progettata e sviluppata su un server Java (es. Tomcat), richiamandone i metodi da un server basato su Ruby on Rails (es. Mongrel).
In particolare, per quanto riguarda Ruby, si dovrebbe utilizzare la gemma SOAP4R, che però nelle ultime versioni è inclusa direttamente nel pacchetto ufficiale.

Un piccolo esempio di tutto ciò si può realizzare in pochi semplici passi, non c’è neanche bisogno di scrivere un vero tutorial.

  • Creare una Web Application con un Web Service in Java e deployarla su Tomcat:
@WebService()
public class MyWebService {
    @WebMethod(operationName = "sayHello")
    public String sayHello(@WebParam(name = "firstName")
    String firstName) {
        return "Hello, " + firstName + "!";
    }
}
  • Creare un progetto in Rails e richiamare il Web Service remoto:
class MyController < ApplicationController
  require 'soap/wsdlDriver'
  
  def index
    XSD::Charset.encoding = 'UTF8'
    wsdl = "http://TOMCAT_SERVER:8080/MyWebApp/MyWebService?wsdl"
    service = SOAP::WSDLDriverFactory.new(wsdl).create_rpc_driver

    result = service.sayHello :firstName => 'Bruno'

    render :text => result.return
  end
end

Ovviamente i due componenti precedentemente descritti potranno anche stare sulla stessa macchina, comunicando tramite l’interfaccia di loopback.

C’è da ricordare che lo standard XML dei Web Services permette di ritornare come output soltanto i seguenti tipi di dato:

  • Boolean
  • Byte
  • Double
  • Datatype
  • Decimal
  • Enumeration
  • Float
  • Int
  • Long
  • Qname
  • Short
  • String
  • TimeInstant
  • UnsignedByte
  • UnsignedInt
  • UnsignedLong
  • UnsignedShort
  • Array dei suddetti tipi

quindi per passare tipi di dati complessi da un’applicazione all’altra sarà necessario implementare dei metodi di serializzazione/deserializzazione sugli oggetti.

PS: un motivo in più per utilizzare NetBeans, che dalla versione 6 supporta anche Ruby on Rails e PHP! :)


Mi capita sempre + spesso di parlare di AJAX e descriverlo come “facile da programmare” a persone che ancora non si sono avvicinate alla programmazione web avanzata. E’ ovvio che in questo caso non riesco ad essere molto credibile! :)
Quindi ecco qui una ppppiiiiccola guida passo passo per comprendere cosa veramente ci permette di fare questa nuova tecnologia. Credo che per leggere tutto senza fatica serva un minimo di conoscenza della programmazione web… o una bella fantasia! :P
Ah, per realizzare il tutto è necessario avere installati sulla propria macchina, o anche su una macchina remota, un server HTTP (io uso Apache 2.2) funzionante con PHP ed un server MySQL. Tutto open source naturalmente… basta scaricare ed installare! ;)

AJAX (Asynchronous Javascript and XML)… tutto si basa sul concetto di “comunicazione asincrona” con il server: noi clicchiamo su un link o un pulsante per eseguire un’azione su dei dati remoti (che possono essere righe di database, file sul disco del server, ecc…) e ne vediamo subito le conseguenze, ancor prima che le azioni siano comunicate al server.
Quindi, mentre noi andiamo avanti a navigare e a fare altro, un javascript si occupa (con molta tranquillità) di comunicare al server l’azione che abbiamo eseguito “virtualmente”… sicchè il server capisce il da farsi ed esegue di fatto le azioni.
Il vantaggio? E’ stato eliminato il tempo di latenza della comunicazione client-server ed anche il reload della pagina! :)

Inoltre, sempre grazie ad AJAX, possiamo cambiare radicalmente il contenuto di una pagina web (tramite manipolazione DOM), richiedendo dati al server in formato XML o testo semplice, e sempre senza ricaricare la pagina… che per siti abbastanza complessi è una vera seccatura!

Andiamo al lato pratico della questione: il fondamento di AJAX è un oggetto javascript che si chiama XMLHttpRequest.
A causa delle differenti implementazioni sui diversi browser, questo oggetto viene creato tramite una funzione cross-browser che si scrive una volta e poi si può dimenticare tranquillamente. :)

function createXMLHttpRequest() {
	try { return new ActiveXObject("Msxml2.XMLHTTP"); } catch (e) {}
	try { return new ActiveXObject("Microsoft.XMLHTTP"); } catch (e) {}
	try { return new XMLHttpRequest(); } catch(e) {}
	alert("XMLHttpRequest not supported");
	return null;
}

Quindi abbiamo capito che questa funzione restituisce il giusto oggetto per le chiamate AJAX, a seconda del browser. Cominciamo mettendola dentro un file di testo e chiamiamolo ajax.js.

Adesso dobbiamo decidere cosa fargli fare. Uhm… facciamo finta di avere una tabella in HTML con tante righe prese dal database sul server… e vogliamo che alla pressione di un pulsantino accanto alla riga, questa venga cancellata dalla pagina e anche dal DB.
Ovviamente la cancellazione “visuale” avverrà subito tramite manipolazione DOM e la cancellazione “reale” avverrà con i suoi tempi tramite una chiamata AJAX.

La parte che ci interessa della pagina HTML, cioè la tabella, potrebbe essere generata da un semplice script PHP, che non riporto. Nell’esempio successivo infatti realizzeremo questo passo in AJAX.

Ma andiamo alla nostra tabella. Nella pagina HTML, in mezzo a tutto il resto, avremo qualcosa del genere:

<html>
<head>
	<title>Test AJAX 1</title>
	<script type="text/javascript" src="ajax.js"></script>
</head>
<body>
<table id="tabella">
	<tr id="riga_1">
		 <!-- QUESTO E' IL DATO PROVENIENTE DAL DB... -->
		<td>Testo 1</td>
		 <!-- ...E QUESTO E' IL PULSANTINO DI ELIMINAZIONE -->
		<td><input type="button" value="Elimina" onclick="elimina_riga(1)" /></td>
	</tr>
	<tr id="riga_2"> <!-- ALTRE RIGHE PER RENDERE LA COSA UN PO' VEROSIMILE -->
		<td>Testo 2</td>
		<td><input type="button" value="Elimina" onclick="elimina_riga(2)" /></td>
	</tr>
	<tr id="riga_3">
		<td>Testo 3</td>
		<td><input type="button" value="Elimina" onclick="elimina_riga(3)" /></td>
	</tr>
</table>
</body>
</html>

… e la funzione Javascript (dentro il file ajax.js) che svolgerà l’azione sarà più o meno così:

function elimina_riga(id) {
	
	// LA RIGA VIENE CANCELLATA DALLA PAGINA WEB
	riga = document.getElementById("riga_"+id);
	riga.parentNode.removeChild(riga); 
	
	// E ADESSO CANCELLIAMOLA _VERAMENTE_ DAL DB
	var xhReq = createXMLHttpRequest();
	xhReq.open("POST", "elimina_riga.php", true);
	xhReq.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
	xhReq.onreadystatechange = function() {
		if (xhReq.readyState == 4)  {
			if(xhReq.status == 200) {
				// PER SICUREZZA CONTROLLIAMO CHE L'AZIONE SIA ANDATA A BUON FINE
				if(xhReq.responseText!="1") {
					alert("Hey, qualcosa è andato storto!");
				}
			}
		}
	}
	xhReq.send("id="+id);
}

Sul server ci sarà uno script elimina_riga.php che esegue l’azione asincrona sul database. Per completezza:

<?php
if(is_numeric($_POST['id'])) { // EVITIAMO ATTACCHI DI SQL INJECTION

	mysql_connect('localhost', 'username', 'password'); // CONNESSIONE AL DB
	mysql_select_db('database');

	if(mysql_query("DELETE FROM tabella WHERE id=".$_POST['id']))
		echo "1"; // ET VOILA'... RIGA CANCELLATA!
	else
		echo "0";
}
?>

Ho omesso tutti i controlli su un’eventuale autenticazione (che si potrebbe fare molto facilmente con le variabili di sessione del PHP), perchè è un argomento che non riguarda questo tutorial.

Beh… a questo punto il primo passettino con AJAX è stato fatto! :)
Adesso possiamo vedere qualcosa di più complicato… la richiesta di dati in formato XML!

L’XML è utile per organizzare i dati in una struttura ad albero schematica e allo stesso tempo flessibile dal punto di vista del programmatore.

Supponiamo di voler creare la tabella HTML dell’esempio precedente, utilizzando i dati presi dal database: la tabella sarà creata al carimento della pagina tramite una XMLHttpRequest e la manipolazione DOM del documento.

La pagina HTML dovrà associare all’evento di caricamento della pagina la funzione javascript per la creazione della tabella:

<html>
<head>
	<title>Test AJAX 2</title>
	<script type="text/javascript" src="ajax.js"></script>
</head>
<body onload="popola_tabella()">

<table id="tabella">
</table>

</body>
</html>

leggi_tabella.php è uno script PHP lato server che produce il file XML che ci serve per popolare la nostra tabella:

<?php
header("Content-Type: text/xml");
echo "<?xml version="1.0" encoding="ISO-8859-15" standalone="yes"?>\n";

mysql_connect('localhost', 'username', 'password'); // CONNESSIONE AL DB
mysql_select_db('database');

?>
<tabella>

<?php
$query = mysql_query("SELECT id, testo FROM tabella");
while($riga = mysql_fetch_assoc($query)) {
?>
	<riga id="<?=$riga['id']?>"><?=$riga['testo']?></riga>
<?
}
?>

</tabella>

Il risultato che avremo sarà come questo:

<?xml version="1.0" encoding="ISO-8859-15" standalone="yes"?>
<tabella>
	<riga id="1">Testo 1</riga>
	<riga id="2">Testo 2</riga>
	<riga id="3">Testo 3</riga>
</tabella>

e servirà una funzione javascript per richiedere la pagina XML al server ed interpretarla per farla diventare codice HTML.

Dentro ajax.js avremo la funzione principale:

function popola_tabella() {
	var xhReq = createXMLHttpRequest();
	xhReq.open("POST", "leggi_tabella.php", true);
	xhReq.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
	xhReq.onreadystatechange = function() {
		if (xhReq.readyState == 4)  {
			if(xhReq.status == 200) {
				xml = xhReq.responseXML;
				if(xml!=null) {
					// INDIVIDUA L'ELEMENTO tabella NELLA PAGINA HTML
					tabella = document.getElementById("tabella"); 
					// ELEMENTO tabella NEL FILE XML
					var xmlTabella = xml.getElementsByTagName("tabella")[0];
					// TUTTE LE RIGHE DELLA TABELLA NEL FILE XML 
					var xmlRighe = xmlTabella.getElementsByTagName("riga");  

					for(i=0;i<xmlRighe.length;i++) { // PER OGNI RIGA....
						xmlRiga = xmlRighe<i>;

						// LEGGE L'ID DELLA RIGA
						id = xmlRiga.getAttribute("id");

						// LEGGE IL TESTO CONTENUTO
						testo = xmlRiga.childNodes[0].nodeValue;

						// CREA UNA NUOVA RIGA
						riga = document.createElement("tr");

						// IMPOSTA L'ID
						riga.setAttribute("id","riga_"+id);

						// CREA LA CELLA CON IL TESTO
						cella1 = document.createElement("td");      
						cella1.innerHTML = testo;

						// CREA LA CELLA CON IL PULSANTE ELIMINA
						cella2 = document.createElement("td");       

						// CREA IL PULSANTE ELIMINA
						elimina = document.createElement("input");  
						elimina.setAttribute("type","button");
						elimina.setAttribute("value","Elimina");
						elimina.onclick = function() { elimina_riga(id); };

						// AGGIUNGE IL PULSANTE ELIMINA ALLA CELLA
						cella2.appendChild(elimina);

						// AGGIUNGE LE CELLE ALLA RIGA
						riga.appendChild(cella1);
						riga.appendChild(cella2);

						// AGGIUNGE LA RIGA ALLA TABELLA
						tabella.appenChild(riga);
					}
						
				}
			}
		}
	}
	xhReq.send("");	
}

E’ da notare che il codice che viene scritto dopo xhReq.onreadystatechange = function() { è da trattare come una funzione separata, che viene invocata quando la virtual machine rileva un cambiamento dello stato della XMLHttpRequest. Ciò implica che non potremo accedere da questo codice alle variabili utilizzate all’interno della funzione chiamante.

… direi che abbiamo finito! :lol:

Bene! :) Adesso chi volesse approfondire potrebbe utilizzare questi piccoli esempi come base per costruire qualcosa di più complesso. Vi assicuro che quanto c’è di più difficile nella programmazione AJAX è stato trattato in questo tutorialino-ino-ino! ;)

Maggiori informazioni sulle funzioni per la manipolazione DOM le potete trovare facilmente su Google.

Sperando di essere stato utile a qualcuno… vi auguro buona programmazione! :D


January 16, 2007 00:00 - 15 comments

Molti sono scoraggiati ad imparare a programmare in Java Enterprise Edition (J2EE) dalle difficoltà nell’impostazione dell’ambiente di lavoro nel proprio PC di casa.
La scelta dei componenti e la poca documentazione “user-friendly” reperibile in rete contribuiscono a lasciare J2EE relegato in ambito aziendale, dove di solito si trova un sistema di server già pronti all’uso e… bisogna solo programmarci dentro.

Anch’io ho rimandato l’approccio a questo ambiente più di quanto volessi, ma a questo punto posso confermare che è più facile di quello che sembra! :D

Prima di tutto c’è da fare una doverosa introduzione: avevo sempre sentito parlare male di Java, a causa della sua pesantezza e della conseguente lentezza. Ad un certo punto mi sono chiesto il motivo per cui è così diffuso nelle aziende… e vi assicuro che è INCREDIBILMENTE diffuso!

Mi sono dato una spiegazione dopo diversi colloqui di lavoro: è frequente che un’azienda abbia la necessità di sviluppare diverse forme di interazione con un unico ambiente centrale, un “core”, che dovrà dialogare con client sviluppati in vario modo (interfacce testuali, grafiche, per dispositivi mobili, interfacce web, eccetera)… ed in questa ottica Java mette a disposizione dei programmatori una stuttura orientata al riutilizzo del codice già scritto, alla scalabilità ed al lavoro di gruppo.
Ne risulta che l’azienda ci guadagna… ed anche tanto!

Andiamo all’aspetto pratico. Bisogna decidere quali programmi utilizzare come application server e come ambiente di sviluppo.
Come Wikipedia insegna, un application server è un software che fornisce l’infrastruttura e le funzionalità di supporto, sviluppo ed esecuzione di applicazioni e componenti server in un contesto distribuito. Si tratta di un complesso di servizi orientati alla realizzazione di applicazioni per il web, multilivello ed enterprise, con alto grado di complessità.
Sapendo per certo che in queste diatribe ne escono sempre vincitori i rappresentanti del software libero, sia come sicurezza che come reperibilità (ed anche per i costi!!!), non ho neanche guardato il software commerciale (WebSphere di IBM, Oracle AS, Weblogic, …).
La scelta, per quanto riguarda l’AS, è ricaduta sul progetto open-source più sviluppato e più supportato da una vasta comunità di sviluppatori: JBoss.

E’ possibile scaricarlo direttamente dalla sezione download del sito ufficiale (io ho optato per l’ultima release stabile, che al momento è la 4.0.5).

Un IDE di sviluppo che qualche mese fa mi è risultato ottimo nella programmazione Java (standard e mobile) è stato Eclipse (anch’esso open source), quindi mi sono informato se fosse possibile renderlo interoperabile con le strutture J2EE. Le soluzioni erano diverse, ma alla fine ho deciso scaricare JBoss Eclipse IDE, una versione di Eclipse modificata direttamente dagli sviluppatori di JBoss, con installati tutti i plugin necessari al funzionamento in accoppiata con l’application server.

Ah… ovviamente la macchina server è equipaggiata con una stupenda Slackware Linux 11.0! ;)
(tutte le indicazioni seguenti riguardano Slackware, ma sono facilmente riportabili ad altre distribuzioni)

L’installazione di JBoss è semplice, basta estrarre l’archivio:

$ cd /opt
$ unzip /path/to/downloaded/jboss-4.0.5.GA.zip
$ ln -s jboss-4.0.5.GA jboss

Non bisogna compilarlo perchè è anch’esso scritto in Java, quindi è multi-piattaforma e gira sotto la Java VM ;)

Prima di far partire il server è necessario installare JDK, qualora non fosse già presente nel sistema, per poi impostare qualche variabile d’ambiente:

$ ln -s /usr/lib/jdk1.5.0_09 /usr/lib/java
$ export JBOSS_HOME='/opt/jboss'
$ export JAVA_HOME='/usr/lib/java'
$ export CLASSPATH='/usr/lib/java/lib/tools.jar'

A questo punto si potrà lanciare JBoss eseguendo

/opt/jboss/bin/run.sh > /dev/null &

(uso la redirezione dell’output per evitare che la shell sia inondata dai messaggi di debug anche con il programma messo in background)

E’ consigliabile salvare uno script d’avvio in

/etc/rc.d/rc.jboss
, in modo da poter decidere se lanciare il server al boot della macchina dando o meno l’attributo di esecuzione al file:

case "$1" in
  start)
    echo "Starting JBoss:  /opt/jboss/bin/run.sh"
    export JBOSS_HOME='/opt/jboss'
    export JAVA_HOME='/usr/lib/java'
    export CLASSPATH='/usr/lib/java/lib/tools.jar'
    /opt/jboss/bin/run.sh > /dev/null &
  ;;
  stop)
    echo "Stopping JBoss..."
    /opt/jboss/bin/shutdown.sh -S > /dev/null &
  ;;
  restart)
    echo "Restarting JBoss..."
    /opt/jboss/bin/shutdown.sh -S > /dev/null &
    /opt/jboss/bin/run.sh > /dev/null &
  ;;
  *)
    echo "Usage: $0 {start|stop|restart}"
    exit 1
  ;;
esac

Adesso è il turno di JBoss IDE:

# cd /usr/local
# tar xfvz /path/to/downloaded/JBossIDE.tar.gz
# chmod +x /usr/local/eclipse/eclipse

Sarà necessario eseguire Eclipse come root, per fare in modo che il server possa essere gestito dall’interno dell’applicazione. Per fare ciò, utilizzeremo il programma sudo, modificando il file

/etc/sudoers
in questo modo:

# User alias specification
#### inserisci qui gli utenti sviluppatori ####
User_Alias     JBOSS_DEVEL = bruno, pippo 
# Cmnd alias specification
Cmnd_Alias     JBOSS_IDE = /usr/local/eclipse/eclipse
# User privilege specification
JBOSS_DEVEL     ALL = NOPASSWD: JBOSS_IDE

Poi basterà lanciare JBoss IDE con il comando

$ sudo /usr/local/eclipse/eclipse

(ed eventualmente aggiungere un’icona sul desktop che lanci questo comando).

Prima di iniziare a programmare, sarà necessario impostare su Eclipse i parametri del server JBoss nella finestra Run > Debug…, cliccando a sinistra su JBoss 4.0.x e poi su New.
Ovviamente la home directory deve essere impostata su

/opt/jboss
.

A questo punto sarà possibile iniziare un nuovo progetto J2EE, aggiungere componenti come EJB e Servlet, impostare le XDoclet, effettuare il packaging ed eseguire debug e deploy sulle proprie web-app! :)

Adesso la cosa migliore da fare è seguire un buon TUTORIAL per imparare velocemente ad usare tutti questi simpaticissimi giocattoli :)


July 26, 2006 12:45 - No comments yet

Sono riuscito a trovare qualche minuto di tempo nelle movimentatissime giornate trentine per riscrivere il tutorial sull’installazione di Slackware sul Sony VAIO S3XP.

Adesso è tutto aggiornato al kernel 2.6.17.4, ma presto arriverà un altro update, in occasione del bugfix per la scheda audio.