• px: Ofrece el máximo de precisión a la hora de indicar un tamaño. Aunque se olvidan del usuario, no hacen caso a la configuración del visitante.
• em: Los más difíciles de cuadrar debido al concepto tan abstracto que los envuelve, pero ofrece una forma de ofrecer al usuario mayor control sobre el texto.
• %: Sin duda la opción más limpia y clara de enteder.
• pt: Los pensados para ser usados únicamente para impresión. Están basados en puntos reales de tinta en un papel.
• palabras clave: Sorprendentemente se trata de una de las técnicas más consistente en todos los navegadores.

Conociendo las técnicas y las peculiaridades de cada uno podremos ajustar más nuestro CSS a nuestras necesidades.

Actualización

Las palabras clave o keywords son los que conocemos como xx-small, x-small, small, medium, large, x-large, xx-large. Dependen completamente de la configuración del cliente, que al igual que % y em, permiten que sea la configuración del visitante defina el tamaño ideal.

Ejemplos

Esto es una fuente a tamaño large

Esto es una fuente a 125% del tamaño. (Usa el tamaño del elemento padre como referencia)

Esto es una fuente a 1.3em.

Esto es una fuente a 24px.

Esto es una fuente a 24pt.

Fuente anieto2k

<script type="text/javascript" src="jquery-1.2.6.js"></script>

Incluimos tanto el estilo que se mostrará la primera vez que el visitante acceda a la página como los estilos alternativos que deseemos.

<link rel="stylesheet" type="text/css" href="Estilos.css" title="Normal" media="screen" />

<link rel="alternate stylesheet" type="text/css" href="EstiloRojo.css" title="Rojo" media="screen" />

<link rel="alternate stylesheet" type="text/css" href="EstiloNegro.css" title="Negro" media="screen" />

Lo importante es asignarle un atributo “title” con un nombre que posteriormente utilizaremos para identificarlo.

Lo siguiente es crear los enlaces, que deben tener la clase “styleswitch” y el atributo “rel” con el nombre que aparece en el “title” del estilo al que vamos a pasar.

<ul>

<li><a href="Ejemplo.html" rel="Normal" class="styleswitch">Estilo 1</a></li>

<li><a href="Ejemplo.html" rel="Rojo" class="styleswitch">Estilo 2</a></li>

<li><a href="Ejemplo.html" rel="Negro" class="styleswitch">Estilo 3</a></li>

</ul>

Ahora tan sólo queda incluir el script de Kelvinluck.com, que se ayuda de un par de funciones de Quirksmode.

<script language="javascript">

/**

* Styleswitch stylesheet switcher built on jQuery

* Under an Attribution, Share Alike License

* By Kelvin Luck ( http://www.kelvinluck.com/ )

**/

(function($){

$(document).ready(function() {

 $('.styleswitch').click(function()

 {

 	switchStylestyle(this.getAttribute("rel"));

 	return false;

 });

 var c = readCookie('style');

 if (c) switchStylestyle(c);

});

function switchStylestyle(styleName) {

 $('link[@rel*=style][title]').each(function(i)

 {

 	this.disabled = true;

 	if (this.getAttribute('title') == styleName) this.disabled = false;

 });

 createCookie('style', styleName, 365);

}

})(jQuery);

// cookie functions http://www.quirksmode.org/js/cookies.html

function createCookie(name,value,days){

 if (days)	{

 	var date = new Date();

 	date.setTime(date.getTime()+(days*24*60*60*1000));

 	var expires = "; expires="+date.toGMTString();

 }

 else var expires = "";

 document.cookie = name+"="+value+expires+"; path=/";

}

function readCookie(name){

 var nameEQ = name + "=";

 var ca = document.cookie.split(';');

 for(var i=0;i < ca.length;i++)

 {

 	var c = ca[i];

 	while (c.charAt(0)==' ') c = c.substring(1,c.length);

 	if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);

 }

 return null;

}

function eraseCookie(name){

 createCookie(name,"",-1);

}

// /cookie functions

</script>

Ya tenemos realizado un intercambiador de estilos que recordará nuestra elección cada vez que carguemos la página.

Revisando los posts del foro, en un rato que he tenido, me he encontrado babySteps, un plugin que hans me muestra y que se encarga de dividir formularios en partes. Un componente ideal para formularios rápidos y complicados.

Revisando el plugin he visto que tu defines los puntos de corte y eso no me acaba de gustar, el tener que poner elementos que no tendrían ningún sentido si no fuera por el plugin no me ha gustado mucho. Así que me montado un pequeño script, que usando jQuery, nos permite obtener lo mismo siguiendo un poco más la semántica del HTML.

stepForm()

Simplemente es una función que se encarga de convertir todos los formularios cuyo atributo class sea stepMe. Únicamente se encarga de cortar el formulario por elementos <fieldset /> haciendo que un formulario largo aparente ser varios de menor tamaño.

Veamos un ejemplo que he montado.

<form action="" method="post" class="stepMe">
	<fieldset>
		<label for="name">Nombre:</label>
		<input name="nombre" id="name" value="" />
		<label for="surname">Apellidos:</label>
		<input name="apellidos" id="surname" value="" />
		<label for="birthday">Fecha de Nacimiento:</label>
		<input name="fnac" id="birthday" value="" />
	</fieldset>
	<fieldset>
		<label for="text1">Text1:</label>
		<select id="text1">
			<option>1</option>
			<option>1</option>
			<option>1</option>
			<option>1</option>
			<option>1</option>
		</select>
		<label for="text2">Text2: </label>
			<input type="radio" id="text2" />
	</fieldset>
	<fieldset>
		<label for="submit">Submitar datos </label>
		<input type="submit" id="submit" value="Enviar" />
	</fieldset>
</form>

Este ejemplo nos divide la página en 3 pasos. Para permitir al usuario moverse entre los pasos he añadido un enlace “Volver” y otro “Seguir“, pero no descarto añadir una pequeña paginación esta noche

Personalización

Podemos definir nuestro propio estilo para los enlaces que se añaden mediante el uso CSS de las clases .nextStep y .backStep.

Además, podemos definir el texto que queremos mostrar en ambos enlaces pasándolo como parámetro. Disponemos de 3 parámetros:

1. Texto Back. (por defecto Volver)
2. Texto Next. (por defecto Seguir)
3. Contenedor. (por defecto fieldset)

$.stepForm();
// Volver / Seguir [fieldset] 

$.stepForm('Back','Next');
// Back / Next [fieldset]

$.stepForm('<-','->', 'p');
// Volver / Seguir [p]

Si somos reacios a usar <fieldset /> podemos pasar como 3er parámetro el tag que vamos a usar como contenedor.

Código

jQuery.extend({
    stepForm: function(txtBack, txtNext, token){
    	var fieldsets = $((token || 'fieldset'), $("form.stepMe"));
        var total = $(fieldsets).length;
	$(fieldsets).each(function(x,el){
			    if (x > 0) {
			      $(el).hide();
			      $(el).append('<a class="backStep" href="#x_' + (x-1) + '">'+ (txtBack || 'Volver') +'</a>');
			      $(".backStep", $(el)).bind("click", function(){
			                $("#x_" + (x - 1)).show();
			                $(el).hide();
			       });
			    }

			    if ((x+1)< total) {
			        $(el).append('<a class="nextStep" href="#_' + (x+1) + '">'+(txtNext || 'Seguir')+'</a>');
			        $(".nextStep", $(el)).bind("click", function(){
			                $("#x_" + (x + 1)).show();
			                $(el).hide();
			        });
			    }
			    $(el).attr("id", "x_" + x);
	});
    }
});

Actualización

Marco Neumann  ha portado el script a MooTools para los usuarios de este framework. La verdad es que la claridad del código no tiene comparación.

Divide formularios en pasos con jQuery » »

Preloaders.net » »

Estas son algunas frases importantes a tener en cuenta cuando programamos nuestras aplicaciones.

“Depurar codigo es dos veces mas dificil que escribir codigo, por lo tanto si escribes el codigo tan inteligentemente como te sea posible, por definicion no seras lo suficientemente inteligente como para depurarlo”

“Hay solo dos tipos de lenguajes: de los que la gente se queja y los que nadie usa”

“Cualquier idiota puede escribir codigo que un ordenador entienda, los buenos programadores escriben codigo que los humanos pueden entender”

“Medir el progreso de programacion en lineas de codigo es como medir el progreso de construccion de un avion en peso”

“La mayoria del soft actual es parecido a una piramide egipcia, con millones de ladrillos apilados uno encima del otro, sin integridad estructural, hecho con fuerza bruta y miles de esclavos”

“Los programas deben ser escritos para que la gente los lea (entienda) y solo incidentalmente para que los ejecuten las maquinas” 

“Si quieres ponerte a desarrollar el próximo bombazo, no necesitas millones de dólares en capital. Necesitas embutir la nevera con pizzas y cola light, un PC baratero en el que trabajar, y la dedicación para llevarlo hasta el final”

Traducción de los comentarios de Meneame. Fuente original

Definiciones como:

• LINQ es un modelo uniforme de programación para todo tipo de información. LINQ permite ejecutar consultas y manipular información con un modelo consistente que es independiente de los recursos de datos.
• LINQ es otra herramienta para consultas SQL embebidas en código
• LINQ es todavía una capa de abstracción de datos.

Todas estas descripciones son correctas, pero hay que tomar en cuenta algo importante:

LINQ puede hacer más de simples consultas SQL embebidas, es mas simple y fácil que un modelo de programación uniforme, y es más aya de una capa de modelado de información.

LINQ es una metodología que simplifica y unifica la implementación de cualquier tipo de acceso a datos. LINQ no te obliga a utilizar una arquitectura específica, si no que te facilita la implementación de arquitecturas ya existentes para el acceso a datos.

Actualmente la información que se maneja por un programa puede pertenecer a diferentes dominios de datos, un array, un objeto, un documento XML, una base de datos, un archivo de texto, una clave de registro, un mensaje de correo electrónico, un mensaje de SOAP, un archivo de excel de office, en fin muchos recursos de datos.

Cada dominio de datos tiene un modelo de acceso específico, me refiero que por ejemplo si queremos hacer una consulta a base de datos ocupamos SQL, si queremos navegar en un XML usamos DOM o XQuery, si queremos sacar información de un array, mediante una iteración, si deseamos ver un documento de texto podemos ocupar Office, etc.

Realmente el problema es poder unificar todo este tipo de estructuras de acceso, que es lo que se ha venido intentando anteriormente. LINQ viene a resolver este tipo de problemas, brindándonos una manera uniforme de acceso y manipulación de información.

LINQ es un modelo de programación que introduce consultas como primer concepto de clase en cualquier lenguaje de .NET.

Por ejemplo:

var query= from c in Customers where c.Country==”Italy” select c.CompanyName;

Ahora Visual Studio 2008 nos da la gran característica de tener un tipo de datos llamado var, por ejemplo si tenemos en este caso una variable var, y le asignamos una cadena como valor, identificara que el tipo de datos que se manejara sera string, de lo contrario si colocamos valores numéricos, identificará que sean entero, flotante, decimales, etc.

Entonces decimos que en nuestra variable query va a contener nuestra consulta y la mostraremos de esta forma:

foreach (string name in query) {

Console.WriteLine (name); }

Esta consulta también podemos aplicarla a SQL embebido, o a un dataset, o un array de objetos en memoria, o a muchos tipos de información, por ejemplo Customers puede ser una colección de objetos.

Customer[] Customers;

Customers puede ser un DataTable en un DataSet:

DataSet ds= GetDataSet();

DataTable Customers = ds.Tables[”Customers”];

Customers puede ser una entidad de clase que describe una tabla fisicamente en una relacion en base de datos:

DataContext db=new DataContext (ConnectionString);

Table<Customer> Customers =db.GetTable<Customer>();

O bien Customers puede ser una entidad de clase que describe un modelo conceptual y que es indicado en una relación de base de datos.

NorthwindModel dataModel =new NorthwindModel();

ObjectQuery<Customer> Customers =dataModel.Customers;

Como podemos ver, es similar a sintaxis SQL a lo cual en LINQ se le conoce como expressiones de consulta. Los lenguajes que implementan SQL embebido definen solo una simple sintaxis para colocar sentencias SQL en diferentes lenguaje, pero digamos que estas sentencias no estan integradas en la sintaxis del lenguaje nativo y el tipo de sistema.