¿Qué es un sistema de control de versiones? Para explicarlo de forma sencilla, podríamos decir que es una forma de guardar todo el historial de un proyecto de forma que se almacenan todas las modificaciones que vamos haciendo sobre los archivos que editamos (que ha cambiado, quien lo ha cambiado, que había antes…).

Hay otros sistemas de control de versiones como Subversion o CVS, sin embargo GIT ha conseguido mucha popularidad en poco tiempo por ser muy fácil de usar y estar creado por Linus Torvalds (el del pingüino). Ademas, muchos de los grandes proyectos de hoy en día lo están usando (Ruby on Rails, jQuery, Android, Wine, Fedora, VLC, Gnome, etc).

Para los no iniciados en ningún sistema de estos, empezar puede resultar un poco difícil. En este post voy a intentar explicar los comandos básicos para iniciarnos en GIT.

GIT tiene muchas ordenes, pero con unas pocas podemos defendernos y trabajar perfectamente.

Antes de nada, necesitamos un servidor GIT (no es realmente necesario, pero para un trabajo en equipo hace las cosas mucho mas sencillas).

Para no liarnos en exceso, usaremos alguno de los que podemos encontrar gratuitamente en Internet. Para mi gusto, uno de los mejores es GitHub. Os creáis una cuenta gratuita y seguimos. Venga, que os espero.

¿Ya? Ok.

Ahora vamos a crear nuestra clave SSH. La clave SSH es un archivo que identifica nuestro ordenador. Esta clave debemos almacenarla en local y también enviarla al servidor. Cuando queramos enviar datos de nuestros proyectos al servidor, éste la validará y comprobará si podemos o no hacerlo.

Para no liarme en cómo crear las llaves, os pongo únicamente los enlaces a los tutoriales (muy cortos y fáciles, no os preocupéis) sobre como hacerlo en Windows, Linux y Mac.

Ahora que ya tenemos todo preparado, vamos crear un nuevo repositorio (un proyecto, vaya) pinchando en botón de New Repository.

En la siguiente pantalla, rellenamos los datos que nos piden.

Después de esto, nos aparecerá una pantalla con las instrucciones para empezar a usar GIT. La verdad es que los chicos de GitHub lo han puesto muy fácil y claro todo. De todas formas explicaré un poco las instrucciones.

Lo primero de todo será instalar GIT (duh!). En Linux, podéis buscarlo por el apt-get o similar. Seguro que lo encontrais. Los usuarios de Mac o Windows tendréis que instalarlo a partir del paquete instalador que encontraréis en la pagina oficial de GIT.

Después de la instalación, el siguiente paso será configurar vuestros datos de usuario (solo lo tendréis que hacer la primera vez que usáis GIT, no por cada proyecto que creéis). Con estas directivas nos identificamos en cada commit (guardado de datos en el repositorio) y podremos controlar quien hizo cada cambio en los archivos.

He de decir que los comandos de GIT los vamos a ejecutar en una consola / terminal / ventana de comandos. Aunque hay interfaces gráficas, prefiero hacer esto de la “forma tradicional”. Así que abrimos una nueva ventana de terminal.

Ejecutamos los comandos que ponen en la página de GitHub.

mkdir nombre_de_nuestro_proyecto

Con esto ya tenemos una carpeta en donde vamos a guardar nuestro proyecto.

Ahora nos metemos dentro de la recién creada carpeta.

cd nombre_de_nuestro_proyecto

Iniciamos el repositorio con:

git init

Este comando nos creará una carpeta .git que contendrá todo el historial de los archivos. Nunca, repito, NUNCA deberemos tocar esta carpeta o su contenido, pues podríamos perder todo el historial del proyecto.

El siguiente comando:

touch README

Con esto creamos un archivo vacío llamado README. Podemos hacer esto o podemos meter cualquier archivo que nosotros queramos dentro de la carpeta.

Ahora empieza la parte interesante y que repetiremos continuamente en nuestro trabajo diario:

git add README

git add nombre_archivo es el comando que usaremos para decirle a GIT – oye, prepárate para guardar este archivo en el repositorio.

Es un comando que usaremos continuamente, pues a cada modificación de un archivo existente o inclusión de uno nuevo, tenemos que invocar este comando.

Ahora, el segundo comando más usado:

git commit -m "first commit"

Este comando es el que dice – todos los cambios que he hecho hasta ahora, guárdalos!

Es obligatorio en este comando escribir el -m “mensaje_que_explica_los_cambios_realizados”.

Hasta este momento, nuestra carpeta de proyecto no sabe que tiene que guardarse en GitHub. Es decir, no le hemos dicho que está enlazada con el repositorio que acabamos de crear en nuestra cuenta. Para eso hacemos lo siguiente (sólo lo deberemos hacer una vez).

git remote add origin git@github.com:vuestra_cuenta_de_github/el_nombre_de_vuestro_repositorio.git

¡Ahora ya lo sabe!

Por último, enviamos los datos a GitHub con:

git push origin master

¡Y ya está! ¡Nuestro proyecto ya está subido en GitHub!

Eliminad la carpeta de vuestro ordenador y vamos a descargarla desde el servidor para ver como funciona desde aquí.

¿Ya la habéis eliminado?

Pues id a la pagina de vuestro proyecto. Vereis algo como esto:

Esa cadena que veis git@github.com:vuestra_cuenta_de_github/el_nombre_de_vuestro_repositorio.git es la cadena que identifica la descarga de vuestro repositorio con permisos de escritura. Esto no quiere decir que cualquiera que tenga esa cadena pueda tocar vuestro proyecto. Para eso está lo que os comentaba antes acerca del archivo SSH. Si alguien que no está identificado usa esa cadena, el repositorio no se descargará.

Si le dais al botón Read-Only os dará otra cadena que solo tiene permisos de lectura. Aunque seáis vosotros en vuestro ordenador, los archivos que os descarguéis con esa cadena no podréis volver a subirlos.

Empezamos pues, descargando el repositorio con la primera cadena. Nos vamos de nuevo a la ventana de terminal y escribimos:

git clone git@github.com:vuestra_cuenta_de_github/el_nombre_de_vuestro_repositorio.git

El comando git clone como veis, sirve para descargar el repositorio que se encuentra en esa cadena de conexión.

Modificad ahora cualquier archivo del repositorio. Bien.

Si ahora ejecutáis:

git status

Os dice que el archivo ha sido modificado. Este comando sirve basicamente para eso, para ver que ha cambiado y que no hemos guardado en el repositorio.

Vamos a guardar los cambios realizados.

git add nombre_del_archivo

git commit -m "Modificación de prueba"

Ok, ya vuelve a estar a la última.

Si ahora hacemos un git status veremos como ya nos dice que no hay nada por guardar.

Ahora vamos a ver otro comando:

git rm nombre_del_archivo

Este comando elimina el archivo señalado de nuestro repositorio. Lo borra para siempre… aunque seguimos teniendo su historial hasta este punto.

Para guardar el cambio, como siempre:

git commit -m "Me cargo este archivo que ya no necesito"

Por ultimo, para enviar todos los cambios realizados al servidor, hacemos:

git push

Y nuestro repositorio online volverá a estar actualizado.

¡Ah! ¡Se me olvidaba!

Si algún otro usuario modifica nuestro proyecto, la copia que tenemos en local quedará desfasada, claro. No es necesario volver a descargarse el proyecto. Imaginad que tenéis archivos que aun no los habéis enviado al servidor, pero queréis descargar la copia mas actualizada. Sería un engorro descargar todo de nuevo y poner estos archivos en la nueva copia. Para eso existe el comando:

git pull

Este comando os descargará las actualizaciones que se han realizado en el proyecto sin tocar las cosas que aun no habéis subido.

Ok, pues hasta aquí lo súper básico de GIT. Con esto ya podréis usarlo y si necesitáis mas información, escribidlo en los comentarios.

Es un servicio que está incluido en YSlow, la extensión para Firebug.

Para ver sus efectos hay que instalar firebug, instalar YSlow, cargar una web con firebug abierto, ir a la pestaña de YSlow, pasar el test y por último ir imágen por imagen guardando el resultado.

Además, sólo nos habrá procesado las imagenes de la página cargada.

Como veis es un proceso largo y alguno estará preguntando, ¿no hay otra forma más rapida de hacer todo esto?

Os presento Smusher

Smusher es unaa pequeña utilidad escrita en php que envía una imagen o una carpeta entera (subcarpetas incluidas) al servicio de Yahoo.

Además nos dice el ratio de reducción de peso de cada imagen.

Podeis descargaros el codigo desde mi pagina de github.

Para quien no lo sepa, decir que es una pequeña aplicación de java que se ejecuta en un terminal / consola, a la que le pasas como parámetros los archivos javascript y css que quieres comprimir. El programa elimina comentarios y renombra variables para reducir el código y por tanto, el peso del fichero.

Es un proceso un poco tedioso sí tenemos muchos archivos porque hay que especificar la ruta de cada uno. Así que hice un pequeño programa que se ejecuta en php-cli que comprime todos los ficheros que haya en una carpeta con sólo una instrucción nuestra. También podemos decirle que nos una todos los archivos en uno sólo (genial para acelerar la descarga de nuestras páginas web) y algunas opciones más.

Podéis echarle un ojo y descargarlo desde la página de github.

Hace tiempo que me venia rondando la cabeza el hacer una web para poder comprar, vender y cambiar juegos entre los mismos usuarios sin necesidad de ningún tipo de intermediario. Algo así como un eBay, pero enfocado únicamente los videojuegos.

Bueno, pues ya está en marcha.

La pagina se llama GameMarkt y está lista para usarla.

El ebay de los videojuegos

Algunas de las características que tiene son:

1. Enlazada con Google maps: cada usuario puede poner donde vive (en el grado de detalle que quiera) para localizar más las búsquedas de los títulos.
2. Extracción de la información de la wikipedia: al dar de alta un titulo en el mercado, se intenta extraer toda la información posible desde la wikipedia, para completar los datos del juego.

El proyecto está realizado en php con el framework comodo.

Está basado en la estructura modelo-vista-controlador, es decir, separa los datos, la logica y la interfaz de usuario en tres partes. Como su nombre indica, la programación se lleva a cabo con código Ruby, un lenguaje orientado a objetos inspirado en Perl.

Lo que más llama la atención de Ruby on Rails es que se dice que se consigue hacer cualquier proyecto diez veces más rápido que con otro lenguaje.

Me queda decir también que este framework lleva incorporado de série prototype y scriptaculous haciendo que su uso sea extremadamente sencillo.

AJAX, acrónimo de Asynchronous JavaScript And XML (JavaScript y XML asíncronos), es una técnica de desarrollo web para crear aplicaciones interactivas. Éstas se ejecutan en el cliente, es decir, en el navegador del usuario, y mantiene comunicación con el servidor en segundo plano. De esta forma es posible realizar cambios sobre la misma página sin necesidad de recargarla. Esto significa aumentar la interactividad, velocidad y usabilidad en la misma.

La librería Prototype nos ayuda enormemente a usar AJAX en nuestras aplicaciones.

Vamos a ver como hacerlo con unos sencillos ejemplos.

Teniendo en cuenta el siguiente código PHP que incluiremos en una página llamada laPaginaPHP.php, vamos a realizar tres ejemplos. En cada uno usaremos uno de los tres métodos que disponemos para realizar llamadas AJAX.

if (!empty($_POST['nombre']))
{
//conexión con la base de datos
...
 
//creo un numero aleatorio para el id del usuario que voy a actualizar
$idAleatorio = rand (1, 10);
 
//consulta
$consulta = "UPDATE usuarios SET nombre = $_POST['nombre'] WHERE id=$idAleatorio";
 
//ejecución de la consulta
...
 
//devuelvo un texto de que la operación es correcta
echo "La consulta se realizó correctamente";
}
else
echo "La consulta no ha sido realizada";

Ajax.Request

El método Request nos permite sencillamente ejecutar una petición al servidor y nos devuelve el resultado de dicha petición.

En el siguiente código voy a hacer una petición al servidor cuando el usuario pincha sobre un botón. Esta petición actualizará la base de datos y nos devolverá el resultado.

<script>
	function actualiza()
	{
		Ajax.Request("laPaginaPHP.php", {
			postBody:"nombre=pepitoDeLosPalotes",
			onSuccess: function(objeto)
			{
				alert(objeto.responseText);
			}
		}
	}
</script>
<input type="button" value="pinchame" />

Ajax.Updater

El método Updater se diferencia del anterior, en que este imprime el contenido de la respuesta en el primer parametro de la llamada. En el siguiente ejemplo escribo la respuesta en una capa llamada “capaResultado”.

<script>
	function actualiza()
	{
		Ajax.Updater("capaResultado", "laPaginaPHP.php", {
			postBody:"nombre=pepitoDeLosPalotes"
		}
	}
</script>
<div id="capaResultado"></div>
<input type="button" value="pinchame" />

Ajax.PeriodicalUpdater

El último método que hay es una ampliación del Updater. En este caso, como su nombre indica, la llamada se repetirá indefinidamente con la frecuencia especificada (2 segundos es el valor por defecto). Si el objeto no obtiene respuesta la frecuencia se aumentará automáticamente. En el momento en que obtenga respuesta, la frecuencia volverá a tener el valor que nosotros especificamos en la declaración.

<script>
	function actualiza()
	{
		Ajax.PeriodicalUpdater("capaResultado", "laPaginaPHP.php", {
			frequency: 5,
			postBody:"nombre=pepitoDeLosPalotes"
		}
	}
</script>
<div id="capaResultado"></div>
<input type="button" value="pinchame" />

Como hemos visto el uso del objeto AJAX es muy sencillo. En estos ejemplos no he añadido apenas opciones ni callbacks, las cuales son comunes en los tres métodos.

Algunas de las opciones son las siguientes:

• postBody aqui incluiremos los valores que queramos enviar en formato URL (“nombre=pepito&apellido=fernandez&edad=15″)
• method determina la forma en la que enviamos el contenido. Este puede ser “post” o “get”
• asynchronous indica si la llamada será síncrona o asíncrona. Los valores son true o false

Y algunos callbacks son:

• onFailure función personalizada que se ejecutará cuando la llamada haya sido completada con algun error
• onSuccess función personalizada que se ejecutará cuando la llamada haya sido completada correctamente

Con esto hemos visto lo básico acerca de ajax y su utilización, asi que ya podeis ir haciendo vuestros pinitos

Hasta ahora programar con javascript era algo tedioso y aburrido (almenos para mi). Desde que estoy usando esta librería, la programación se ha vuelto rápida, agil y lo que es mejor, divertida.

Desde hace un tiempo, infinidad de desarrolladores estan adoptándolo en sus proyectos y creando verdaderas obras de arte en cuanto a diseño de interfaz y herramientas para la web se refiere.

Pero, ¿que es lo que tiene Prototype que lo hace tan agradable para los desarrolladores?

Sigue leyendo y te explico un poco de que va todo esto…

Prototype aporta una serie de utilidades que hacen muy fácil la creación de complejas librerias y funciones javascript. Estas son algunas de ellas (las que más comunmente uso):

Función $()

Esta función es “simplemente” un atajo de document.getElementById(). Pero va un poco más lejos. Podemos recoger una série de elementos con ella de tal forma que nos devolverá un array de elementos.

Ejemplo:

<script>
	function test1()
	{
		var miCapa = $('capa1');
		alert(miCapa.innerHTML);
	}
 
	function test2()
	{
		var misCapas = $('capa1','capa2');
		for(i=0; i<miscapas .length; i++)
		{
			alert(misCapas[i].innerHTML);
		}
	}
</script>
<div id="capa1">Un texto</div>
<div id="capa2">Otro texto</div>
<input type="button" value="funcion1" onclick="test1();"/><br />
<input type="button" value="funcion2" onclick="test2();"/><br />
</miscapas></script>

Función $F()

Otra función que es muy cómoda de usar. Esta nos recogera el valor del elemento de formulario que le indiquemos.

<script>
	function test()
	{
		var valor = $F("saludo");
		alert(valor);
	}
</script>
<input type="text" value="hola que tal" id="saludo" onClick="test();" />

Sobretodo tened en cuenta que es sólo para recibir el valor, no para asignarlo. Por lo tanto la siguiente línea estaría mal.

$F("saludo") = "muy bien, gracias";

Función $A()

Esta función nos convertirá en un array aquello que le pasemos. Por ejemplo:

<script>
	function test()
	{
		var opciones = $("select").options;
		var array_opciones = $A(opciones);
		for(i=0; i<array_opciones .length; i++)
		{
			alert(array_opciones[i].innerHTML);
		}
	}
</script>
<select id="select">
	<option value="1">Primera</option>
	<option value="1">Primera</option>
	<option value="1">Primera</option>
</select>
</array_opciones></script>

Bucles a’la Ruby

Hasta ahora, los bucles los hemos hecho de esta forma:

<script>
	function test()
	{
		for(i=0; i<miselementos .length; i++)
		{
			alert(misElementos[i])
		}
	}
</script>
</miselementos></script>

Ahora con prototype tenemos esta otra forma de hacerlos:

<script>
	function test()
	{
		misElementos.each(function(elemento)
		{
			alert(elemento)
		})
	}
</script>

Ademas de estas y muchas otras funciones, Prototype nos extiende varias clases y objetos que existen actualmente. Algunos de los cuales son:

Extensiones para la clase String

Algunas de ellas son:

• stripTags() devuelve el texto eliminando cualquier tag HTML que puediera tener
• escapeHTML() devuelve el texto escapando cualquier tag HTML que puediera tener
• unescapeHTML() … ¿no lo adivinas?

Extensiones para la clase Array

Algunas de ellas son:

• indexOf(valor) devuelve indice del elemento que tiene el valor que le pasamos
• without(valor1 [, valor2 [, .. valorN]]) devuelve el array sin los elementos que le pasamos a la función

Extensiones para la clase array

Vamos a ver ahora algunos de los nuevos métodos para esta clase:

• indexOf(valor) devuelve indice del elemento que tiene el valor que le pasamos
• without(valor1 [, valor2 [, .. valorN]]) devuelve el array sin los elementos que le pasamos a la función

Extensiones para el objetoEvent

Algunas de ellas son:

• element(evento) devuelve el objeto que ha llamado al evento
• stop(evento) aborta el comportamiento normal del evento (por ejemplo un enlace)

El objeto Element

Este nuevo objeto nos da útiles funciones para manipular los elementos del DOM.

• addClassName(elemento, clase) asigna, al elemento que se le pasa, la clase css que también se le pasa
• removeClassName(elemento, clase) elimina, al elemento que se le pasa, la clase css que también se le pasa
• show(elem1 [, elem2 [, elem3 [...]]]) muestra el elemento o elementos que se le pasan a la función
• hide(elem1 [, elem2 [, elem3 [...]]]) oculta el elemento o elementos que se le pasan a la función
• toggle(elem1 [, elem2 [, elem3 [...]]]) invierte el valor de la propiedad display del elemento o elementos que se le pasan a la función
• remove(elemento) elimina el elemento del DOM
• scrollTo(elemento) hace un scroll de ventana hasta la posición del elemento que se le pasa
• update(elemento, html) reemplaza el contenido del elemento (innerHTML) con el valor que se le pasa

El objeto Insertion

El objeto Insertion lo usaremos para introducir contenido en el DOM. Tiene 4 métodos: Before, After, Top y Bottom, aunque los cuatro se usan de la misma forma.

	function test()
	{
		new Insertion.Before("miFormulario", "antes de etiqueta <form>");
		new Insertion.After("miFormulario", "después de etiqueta </form>");
		new Insertion.Top("miFormulario", "antes de etiqueta <input />, dentro de <form>");
		new Insertion.Bottom("miFormulario", "después de etiqueta <input />, dentro de </form><form>");
	}
	</form><form id="miFormulario">
		<input type="text" id="miTexto" value="Hola que tal" onClick="test();" />
	</form>

El objeto Field

Este objeto nos da utilidades para trabajar con elementos de formularios. Algunas son:

• clear(campo1 [, campo2 [, campoN]]) vacia el contenido del campo o campos que se le pasan a la función
• focus(elemento) pasa el foco al elemento que se pasa

El objeto Form

Este objeto nos da utilidades para trabajar con formularios. Algunas son:

• serialize(formulario) devuelve una cadena formateada para pasar por URL con los elementos del formulario y sus valores. Esta función nos será muy útil si trabajamos con ajax
• getElements(formulario) devuelve un array con los elementos que pertenecen al formulario
• enable(formulario) activa todos los elementos del formulario
• disable(formulario) desactiva todos los elementos del formulario
• focusFirstElement(formulario) da el foco al primer elemento del formulario

Hasta aquí explico de las bondades de Prototype, aunque no son ni una quinta parte de las que hay. Espero que os sirva almenos para abrir un poco el apetito javascript y que empeceis a programar en este lenguaje que vive su segunda juventud

Os recomiendo encarecidamente que le echeis un ojo a esta pagina http://www.sergiopereira.com/articles/prototype.js.html donde se explican muy bien muchas aportaciones que nos hace Prototype.

Al hacer esta aplicación me encontrado con el problema de la validación del usuario. Resulta que cuando creas un evento en la web te validas por medio de un password codificado en MD5 (con la función md5() de PHP).

En visual basic no existe ninguna función (almenos no la conozco) que te haga esa conversión, asi que tube que escribir una que la hiciese. En las pruebas que he hecho, parece que funciona perfectamente, pero sino, se aceptan comentarios .

Function calculaMD5(ByVal cadena As String) As String
CALCULO EL HASH DE LA CLAVE INTRODUCIDA CON MD5
Dim md5 As New System.Security.Cryptography.MD5CryptoServiceProvider
Dim bytValue() As Byte
Dim bytHash() As Byte
Dim sb As System.Text.StringBuilder = New System.Text.StringBuilder(32)
Dim i As Integer
bytValue = System.Text.Encoding.UTF8.GetBytes(cadena)
bytHash = md5.ComputeHash(bytValue)
md5.Clear()
Dim str As String = ""
 
'bytHash SIEMPRE DEVUELVE PAREJAS DE CARACTERES QUE VOY CONCATENANDO
For i = 0 To bytHash.Length - 1
str = bytHash(i).ToString("x2")
sb.Append(str)
Next
 
'DEVUELVO LA CADENA MD5
Return sb.ToString
End Function

Aquí dejo un ejemplo de código (algo muy sencillito).

Imports System.Data.Common
 
Public Class identificacion
'CREO UN DATASET PARA RELLENARLO CON LA INFO DE LA TABLA
Dim dataset As DataSet = New DataSet
 
Private Sub identificacion_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
'CREO El OBJETO FACTORIA E INDICO EL PROVEEDOR QUE VOY A USAR
Dim factoria As DbProviderFactory =
DbProviderFactories.GetFactory("System.Data.SqlClient")
 
'CREO EL CONEXIONBUILDER PARA PREPARAR LA CONEXION
Dim parametrosConexion As DbConnectionStringBuilder =
factoria.CreateConnectionStringBuilder
 
'PREPARO LA CADENA DE CONEXION
With parametrosConexion
.Add("Data Source", "localhost")
.Add("Initial Catalog", "unica_db")
.Add("Integrated Security", "SSPI")
End With
 
'CREO EL OBJETO DE CONEXION
Dim conexion As DbConnection = factoria.CreateConnection
 
'ESTABLEZCO LA CADENA DE CONEXION
conexion.ConnectionString = parametrosConexion.ConnectionString
 
'ABRO LA CONEXION
Try
'INTENTO LA CONEXION
conexion.Open()
Catch ex As Exception
'SI FALLA, MUESTRO UN MENSAJE Y CIERRO EL PROGRAMA
MessageBox.Show("Error en la conexión con la base de datos. Si el problema
persiste consulte con el Administrador del sistema", _
"Error en la conexión", MessageBoxButtons.OK,
MessageBoxIcon.Error, MessageBoxDefaultButton.Button1)
My.Forms.principal.Close()
Me.Close()
Exit Sub
End Try
 
'PREPARO UN ADAPTADOR PARA OBTENER LA TABLA DE USUARIOS
Dim adaptador As DbDataAdapter = factoria.CreateDataAdapter
 
'CREO UN COMANDO
Dim comando As DbCommand = conexion.CreateCommand
 
'CREO LA CONSULTA
comando.CommandText = "SELECT * FROM tbl_usuarios"
 
'ENLAZO EL ADAPTADOR AL COMANDO
adaptador.SelectCommand = comando
 
'RELLENO EL DATASET
dataset = New DataSet
adaptador.Fill(dataset, "tbl_usuarios")
End Sub
End Class

Este es el codigo de un formulario que accede a una base de datos Sql server. Como podeis ver, establezo los parametros de la conexión en las primeras lineas de programa.
Pues bien. Si decidiese cambiar el tipo de base de datos, por ejemplo a Access, sólo deberia cambiar esas primeras lineas.
En otras versiones, si quisiese hacerlo, tendria que cambiar el codigo de prácticamente todos los objetos que he creado que sirven para relacionarse con la base de datos (comando, dataAdapter, etc).
Espero que haya quedado un poco más claro.

He estado probando un poco la factoria de proveedores de datos de visual basic 2005 express (DbProviderFactories class).

Esta clase sirve para relacionarse con la base de datos pudiendo cambiar el motor en cualquier momento, reescribiendo únicamente la cadena de conexion y especificando el nuevo proveedor. Esto nos vendria bien, por ejemplo, en una aplicación que se relaciona con Access y más tarde queremos cambiar a SQL Server. Anteriormente hacer este cambio significaba reescribir gran parte de la aplicación. Esta clase viene a solucionar este problema.

Los objetos command, dataAdapter, etc. seran independientes del tipo de base de datos.