Zero Bundle es un pack de recursos gratuitos para diseñadores que está disponible para descarga por tiempo limitado. Creado por la gente de Webdesigner Depot y Mighty Deals, ofrece un conjunto de recursos para uso tanto personal como profesional y 100% gratuitos. Iconos, plantillas de Photoshop, imágenes vectoriales, pinceles, texturas… entre otros.

Se puede descargar hasta finales de febrero así que… ¡Corred, insensatos!

Enlace: Zero Bundle

Pero el otro día otro compañero que la está utilizando me planteó una duda: le daba la sensación de que la clase estaba ralentizando la ejecución de su aplicación, la cual utilizaba varios subprocesos para realizar ejecuciones bastante costosas. Yo le comenté que había utilizado mi Logger con aplicaciones que también usaba múltiples hilos e incluso con la Task Parallel Library de .NET 4 y nunca había notado nada raro.

Aún así, me quedó la duda: ¿Es totalmente thread-safe una clase declarada mediante el patrón Singleton?

La respuesta, tras consultar un foro de debate en LinkedIn y un par de blogs, es que… ¿lo adivináis? Depende de vuestra implementación Veámoslo en detalle.

Primera aproximación: El patrón Singleton

Doy por hecho que conoceréis el patrón singleton, ya que es una de los primeros conceptos que se aprenden cuando empiezas a programar. Pero para refrescar la memoria, consiste en diseñar la implementación de una clase para que se cree una única instancia de la misma en toda la aplicación. Aunque hay quien lo llega a considerar un anti patrón por el hecho de depender del uso de métodos y propiedades estáticas y dificultar el unit testing, yo pienso que puede ser muy útil en ciertos casos, siempre que no se abuse de él. Mi clase Logger puede ser un ejemplo perfecto, ya que aseguramos que solamente hay un objeto en toda la aplicación que utiliza un recurso de disco: el archivo de texto en el que se imprime el log.

¿El problema de Singleton? Que no es Thread Safe. Un ejemplo de una mala implementación del patrón Singleton sería la siguiente:

Source code

// Mala implementación!!!
public sealed class MiClase
{
    private static MiClase instance=null;
 
    private MiClase()
    {
    }
 
    public static MiClase Instance
    {
        get
        {
            if (instance==null)
            {
                instance = new MiClase();
            }
            return instance;
        }
    }
}

En el ejemplo anterior, no es thread safe, ya que dos procesos de la aplicación podrían evaluar al mismo tiempo que (instance == null) = true y generar una nueva instancia de MiClase.

Segunda aproximación: uso de bloqueos (lock)

Si el problema es la concurrencia, lo primero que nos viene a la cabeza es utilizar un lock (bloqueo) para proteger el código que genera la instancia del Singleton (o de cualquiera de sus métodos). El lock asegura una barrera de memoria, de forma que solo un proceso puede ejecutar esa porción de código al mismo tiempo hasta que se libera.

Source code

public sealed class MiClase
{
    private static MiClase instance = null;
    private static readonly object padlock = new object();
 
    MiClase()
    {
    }
 
    public static MiClase Instance
    {
        get
        {
            lock (padlock)
            {
                if (instance == null)
                {
                    instance = new MiClase();
                }
                return instance;
            }
        }
    }
}

La implementación anterior soluciona el problema a medias, ya que genera otros nuevos. Si os fijáis, una clase externa que quiera instanciar MiClase, lo haría así:

Source code

MiClase.Instance;

De forma que cada vez que se accede a la propiedad Instance se produce un bloqueo. Y los bloqueos son peligrosos, ya que pueden dejar “frita” nuestra aplicación dependiendo del código que tengan que ejecutar. Así que no es una mala solución en la mayoría de los casos, pero prefiero la siguiente.

Tercera aproximación: ¡Fuera bloqueos!

En C# un constructor estático cuando se crea una instancia de la clase o uno de sus miembros estáticos es referenciado, y se ejecuta una sola vez por dominio de aplicación (AppDomain). Dicho esto, con la siguiente implementación aseguramos que la instancia de MiClase se ejecutará una vez pase lo que pase, sin tener que recurrir a comprobaciones o a bloqueos y optimizando al máximo el rendimiento.

Source code

public sealed class MiClase
{
    private static readonly MiClase instance = new MiClase();
 
    static MiClase()
    {
    }
 
    private MiClase()
    {
    }
 
    public static MiClase Instance
    {
        get
        {
            return instance;
        }
    }
}

Cuarta aproximación: ¡Ponte al día y usa Lazy Loading de .NET 4!

Si los ejemplos anteriores eran bastante estándar e incluso independientes del lenguaje, este es solo para programadores de .NET 4. Pero como es mi caso… ya podéis adivinar que esta última solución es mi preferida. Siempre digo que cuando Microsoft inventa algo, no hay por qué complicarse matando moscas a cañonazos.

A partir de la versión 4 del framework se nos ha incluído la clase System.Lazy<T>, con la que podemos construir de forma “perezosa” y completamente thread-safe un objeto de tipo T.

Source code

public sealed class MiClase
{
    private static readonly Lazy<MiClase> lazy =
        new Lazy<MiClase>(() => new MiClase());
 
    public static MiClase Instance { get { return lazy.Value; } }
 
    private MiClase()
    {
    }
}

El constructor requiere un delegate para construir el objeto de tipo MiClase, algo que se soluciona en una línea con una simple lambda expression. La solución no utiliza bloqueos y asegura no solo una única instancia, sino también una “carga perezosa”, que es otro de los motivos por los que alguien querría utilizar un Singleton. Además, tiene varias propiedades y métodos muy útiles para gestionar la instancia, como

• IsValueCreated, que nos dice si el tipo está inicializado
• Value, que nos devuelve la instancia de tipo T
• Finalize() que ejecuta la instrucción Finalize() del IDisposable y libera recursos de memoria
• Y otros que podéis consultar en la especificación (ver)

En mi opinión, este último ejemplo es óptimo en cuanto a claridad del código y rendimiento.

Conclusión

Espero que os haya sido útil el artículo y que no le perdáis el miedo a los Singleton, muy denostados últimamente. Como siempre, si tenéis alguna sugerencia para mejorar el código, los comentarios son bienvenidos

Dependiendo de unas restricciones de seguridad, para ciertos registros se tenían que eliminar algunos de los nodos del XML. Eso me obligaba a trasladar lógica de negocio a base de datos o bien tratar de aprovechar la potencia del framework .NET y Linq to XML.

Imaginemos que tenemos un string XML con los datos de contactos de clientes y que, en función de los permisos del usuario, no se permite mostrar el teléfono o la dirección de correo electrónico, por ejemplo. El campo XML que nos devolvería la base de datos para un cliente tendría una estructura de este tipo:

Source code

<Contacts>
	<Contact>
		<ContactId>1</ContactId>
		<Name>Jose</Name>
		<Surname>Perez</Surname>
		<Email>pepe@email.com</Email>
		<Phone>93 111 22 33</Phone>
		<Mobile>600 11 22 33</Mobile>
	</Contact>
        <Contact>
		<ContactId>1</ContactId>
		<Name>Alberto</Name>
		<Surname>Garcia</Surname>
		<Email>berto@email.com</Email>
		<Phone>93 333 22 11</Phone>
		<Mobile>600 33 22 11</Mobile>
	</Contact>
</Contacts>

Para tratar el XML, es conveniente crear un método que reciba por parámetro la información de los datos de contacto de los clientes en un string con formato XML y un enumerado con los permisos del usuario que desea consultar los datos.

Source code

private static string ClearXmlInfo(string xmlInfo, IEnumerable permissions)
        {
            string resultXML = string.Empty;
 
            if (string.IsNullOrWhiteSpace(xmlInfo))
                return;
 
            XElement xElement = XElement.Parse(xmlInfo);
 
            var contacts = (from c in xElement.Descendants("Contact")
                           select c);
 
            foreach(contact in contacts)
            {
                if(!permissions.Contains(Permission.ShowEmail))
                    xElement.SetElementValue("Email", string.Empty);
                if(!permissions.Contains(Permission.ShowPhone))
                    xElement.SetElementValue("Phone", string.Empty);
                if(!permissions.Contains(Permission.ShowMobileNumber))
                    xElement.SetElementValue("Mobile", string.Empty);
 
                resultXML += xElement;
            };
 
            return resultXML;
        }

Conclusiones

El ejemplo es sencillo, pero espero que sirva para ilustrar que es bastante fácil recorrer y manipular XML con el framework de .NET y Linq.

No puedo evitar observar a los demás mientras conduzco y pronto me di cuenta de que nuestros hábitos de comportamiento no son demasiado variados. Sin arriesgarme demasiado en generalizar, se podría catalogar a la gran mayoría de conductores en casos típicos y predecibles.

Un ejemplo, para entrar en materia: el del Golf. Nótese que digo “el” y no “la”, porque a ellas les suele gustar más llevar un Polo. El del Golf es el típico caso de estudio al que le gusta conducir con el bracito fuera de la ventanilla y cambiarse de carril bruscamente en los atascos intentando situarse en el que avanza más rápido. Suele adelantarte por la derechita cuando vas en la autopista por el carril central solo para girarse a mirarte y hacerte notar lo ofendido que está por verte ir a una velocidad tan absurda. Y de paso enseñarte el peluco, el cigarro o el dedo.

Luego tenemos al típico transportista. Ese hombre “HOMBRE”, que se tira medio día en la carretera y toda la tarde en el bar y que conduce una furgoneta. El grado de destartalamiento de la furgoneta es indiferente, el caso es ponerla al límite en cada maniobra. Se nota que el vehículo no es suyo, porque tiene unas cuantas abolladuras causadas por aparcar de forma despreocupada. O de oído. Este hombre siempre tiene prisa, así que todos los demás conductores le estorban. Su grado de desesperación es tal que cambia de carril incesantemente haciendo un elegante eslalon, sin señalizar y si te puede hacer frenar presa del pánico, se irá con una sonrisa. Los transportistas, o “furgoneteros”, también son conocidos mundialmente por hacer la típica “finta” cuando cambian de dirección para girar y meterse en una calle transversal. Ya sabéis, eso tan gracioso de abrirse en la dirección contraria a la que quieren girar, para despistar a sus adversarios. Los adversarios somos todos los demás, se entiende. Seguro que os habéis encontrado a alguno.

De la misma familia de primates, deriva el conductor de autobús. En este caso, conductor o conductora, ya es indiferente. Este ejemplar, consciente de la envergadura de su montura, decidió un buen día dejar de cederle el paso a los demás. Desde aquél dia de revelación espiritual, se incorpora a la autopista como un coche de Daytona y entra en las glorietas con el mismo respeto que un cuchillo corta la mantequilla.

Hay ciertos casos que me gusta agrupar como los padres y madres de familia. En el caso de los padres, conducen un monovolúmen. Tratándose de ellas, suele ser un todoterreno. Ellos con el monovolúmen tienen todo el espacio que necesitan para que los niños retocen en la parte de atrás sin tocarles los huevos. Ellas con el todoterreno, tienen la seguridad que necesitan para conducir sin miedo a estamparse y que su coche quede abollado de una forma muy antiestética. Mientras más grande y más alto, mejor. Aunque sea para conducir solo por ciudad, da igual. Si se encuentran con un accidente, es mejor que tu coche sea capaz de pasarle por encima al de los demás como si fuera un tanque. Y si es de noche y tienen un coche delante, es mejor deslumbrarle con tus luces a metro y medio del suelo para que sepa que estás ahí.

Y no podría olvidarme de mi favorito: el del BMW. Tengo una teoría que he mencionado en alguna ocasión por twitter. Creo firmemente que cuando vas a un concesionario y quieres comprarte un BMW, la marca exige como condición indispensable que sus compradores se sometan a una lobotomía antes de darles las llaves. No falla: cuando veas un BMW en la carretera, échate a temblar y si puede ser, apártate de su camino. Prepárate a que te coman el culo, que te adelanten bruscamente mirándote con odio, que te hagan luces aunque vayas a 120 por el carril de la derecha y todo tipo de situaciones inverosímiles que se os pasen por la cabeza. Yo entiendo que conducir un BMW representa mucha presión, pero aún así no entiendo el patrón de comportamiento común que se suele dar en la gran mayoría de sus conductores. 

 Todo eso es generalizar, ¿no?

Pensarás. Pues sí, seguramente esté generalizando pero macho… uno a veces se desespera con las locuras que le hacen los demás conduciendo. No gano para sustos. Necesitaba desahogarme. Ala :p

Soy fan #1 de hacer completamente en CSS cosas que hace unos años solo se podían conseguir con JavaScript. El verdadero desafío es conseguir que el resultado sea compatible en todos los navegadores, pero ahí está la gracia. Como ventaja, te ahorras un montón de código de script innecesario.

Hoy voy a explicar de forma breve cómo están hechos los botones de este blog.

Maquetación

Me gusta utilizar un simple tag <span> para el botón, ya que así me aseguro de que no va a provocar ningún comportamiento indeseado en ningún navegador. Si utilizase un <input>, se podría hacer submit sin que yo lo controlase y los anchors (<a>) solo me gusta usarlos en enlace, por cuestiones de SEO. Manías de programador, supongo.

Source code

<span class="button">Texto del botón &raquo;</span>

Estilos CSS

Esta es la madre de los huevos. El truco para emular el comportamiento del botón al hacer “clic” está en ese desplazamiento de 1px respecto al margen superior que le asignamos al evento .active.

Como podéis comprobar, los bordes se redondean con propiedades de CSS3 tipo “border-radius” y se le da un sombreado al elemento y al texto con “box-shadow” y “text-shadow”. La ventaja de hacerlo así es que en navegadores antiguos, simplemente se verá cuadrado, sin requerir maquetación adicional. Si estáis conforme con perder esta diferencia visual con tal de ganar en ancho de banda, esta solución es idónea.

Para el fondo, se utiliza un pequeño truco para hacer el degradado y que sea compatible con todos los navegadores. Utilizando esta imagen png de 1px de ancho y repitiéndola en el eje horizontal del elemento, ya podemos personalizar el botón con el color que queramos y queda un bonito efecto de degradado.

Source code

.button, .button:visited{
    background: url("img/alert-overlay.png") repeat-x scroll 0 0 #857968;
    border-bottom: 1px solid rgba(0, 0, 0, 0.25);
    border-radius: 5px 5px 5px 5px;
    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.5);
    color: #FFFFFF;
    cursor: pointer;
    display: inline-block;
    position: relative;
    text-decoration: none;
    font-size: 13px;
    font-weight: bold;
    line-height: 1;
    text-shadow: 0 -1px 1px rgba(0, 0, 0, 0.25);
    padding: 8px 14px 9px;
    margin:20px 0;
}
 
.button:visited {
    background-color: #857968;
}
.button:hover {
    background-color: #554236;
    color: #FFFFFF;
}
.button:active {
    top: 1px;
}

Espero que os sea útil. Como siempre, estoy abierto a sugerencias para mejorar este truco en CSS3.

Por último, estas cosas no las aprendo yo solo: me basé en el sencillo tutorial que encontré en ZURB, con varios ejemplos en distintas tonalidades.

También os recomiendo su libro en formato físico, una guía indispensable para aprender cosas sobre tipografía, teoría del color y otros conceptos de diseño web.

Desde este humilde rincón de Internet, ¡felicidades, Smashing Magazine!

jQuery es uno de mis frameworks JavaScript preferidos, por su extensibilidad, la amplia documentación que existe en la Red y la independencia que me da para implementarlo y asegurar que va a funcionar igual de bien en cualquier navegador.

Es muy fácil aprender a trabajar con él, pero su potencia no se basa solo en la capacidad de hacer virguerías con el DOM y animaciones que antes haríamos con Flash. Lo que más me gusta de jQuery es que con tres o cuatro líneas de código consigues lo que antes te costaba mucho más con JavaScript clásico u otro lenguaje de cliente.

Con este artículo me gustaría ilustrar la potencia de jQuery para crear plugins y extender el comportamiento de los elementos de una página.

Lo que queremos

Vamos a crear un plugin para extender el funcionamiento de los objetos tipo textbox de un formulario. El funcionamiento de un textbox es idéntico en todos los navegadores: nos ofrece una caja para que el usuario pueda introducir texto. Con este plugin, haremos que todos los textbox muestren una marca de agua con un texto por defecto.

Maquetación

Empezaremos creando los tres archivos que necesitaremos. El HTML, la hoja de estilos css y el script de jQuery:

Lo primero es maquetar el formulario en HTML. Vamos a hacer algo sencillo, para centrarnos en las posibilidades de jQuery.

Source code

<html>
  <head>
    <title>Ejemplo de formulario con marcas de agua</title>
    <link rel="stylesheet" href="style.css" type="text/css" media="screen" />
  </head>
  <body>
    <form>
      <ul>
        <li>
          <label for="name">Nombre:</label>
          <input type="text" id="name" title="Introduce tu nombre"/>
        </li>
	<li>
	  <label for="surname">Apellidos:</label>
	  <input type="text" id="surname" title="Introduce tus apellidos"/>
        </li>
      </ul>
    </form>
  </body>
</html>

Como podéis comprobar, es tan solo un pequeño formulario en el que se nos pide el nombre y el apellido. Para los formularios, me gusta utilizar listas desordenadas en lugar de listas de definición o divs, porque requieren menos maquetación y esto se traduce en menos ancho de banda consumido. En la cabecera hacemos referencia a una hoja de estilos CSS, así que la crearemos en un archivo independiente, tal y como marca el estándar.

Source code

body{
	font-family:Arial, Verdana, sans-serif;
	font-size:10pt;
	width:500px;
	margin: 30px auto;
}
 
label{
	display:block;
	float:left;
	margin-right:20px;
	width:55px;
}
 
ul{
	margin:0;
}
 
li{
	clear:left;
	margin-top:20px;
	list-style:none;
	overflow:hidden;
}
 
input{
	float:left;
}

También me gusta utilizar el body como un contenedor cualquiera, ya que así uno se ahorra divs innecesarios. Ahora que ya tenemos el formulario listo, ya podemos empezar con jQuery.

Extendiendo el comportamiento del textbox

Vamos a crear un plugin de jQuery, así que lo primero que tenemos que hacer es referenciar a la librería del framework. Podemos descargarla de su sitio oficial (descargar) o enlazarla directamente al repositorio de Google. Yo prefiero hacer esto último, ya que a ellos les sobra ancho de banda y casi nunca se les caen los servidores. Así que ya que nos lo ofrecen…

Source code

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js" type="text/javascript"></script>
<script src="watermark.js" type="text/javascript"></script>

La primera línea es el enlace a la librería jQuery que proporciona Google APIs. Ese enlace garantizará que siempre obtengamos la última versión de la serie 1.x.x. Cuando saquen la versión 2, habrá que cambiar en la parte de “…/jquery/1/jquery.min.js” el 1 por un 2.

La segunda línea hace referencia al archivo donde vamos a crear el código de nuestro script.

El concepto de crear un plugin para jQuery es añadir una función al código de la librería. Esta función llevará el nombre de nuestro plugin y tendrá el comportamiento que nosotros definamos. Así que crear un plugin es algo tan sencillo como esto:

Source code

jQuery.fn.watermark = function() {
  // Aquí irá el código de nuestro plugin
};

La función se añadirá al objeto jQuery.fn de la librería y a partir de este momento podremos utilizarla en cualquier parte de nuestro site.

Si queremos, podemos utilizar el mágico simbolo del dolar $ que seguro habréis visto en muchísimos ejemplos de jQuery. Pero para estar seguros de que el acceso directo no entra en conflicto con otras librerías de JavaScript, protegeremos su uso al ámbito concreto de nuestro plugin:

Source code

(function( $ ){
  $.fn.watermark = function() {
    // Aquí irá el código de nuestro plugin
  };
})( jQuery );

Envolviéndolo en esa función, nos aseguramos de que la variable $ no se usará más que en el ámbito de la función.

Ahora ya podemos llamar a la función watermark desde cualquier elemento DOM instanciado con jQuery. En el siguiente fragmento de código, aplicamos un selector a todos los input de tipo texto para que llamen a la función de nuestro plugin nada más inicializarse:

Source code

$(function() {
  $('input:text').watermark();
});

Para comprobar que esto funciona, completaremos el contenido de la función watermark con el código que queremos.

Source code

(function( $ ){
  $(function() {
    $('input:text').watermark();
  });
 
  $.fn.watermark = function() {
    this.addClass("watermark");
    this.each(function(){
      $(this).val($(this).attr("title"));
    });
  };
})( jQuery );

Fijáos en la diferencia en el uso de this o $(this) dependiendo del ámbito. En el primer caso, this ya es un objeto de jQuery que contiene un array con todos los elementos input de tipo text. En el segundo caso, se recorre el array con el .each() y $(this) hace referencia a cada input por separado dentro del ámbito de cada iteración.

Este código debería mostrar el contenido del atributo title del textbox como texto por defecto:

Crear opciones por defecto

Hasta ahora hemos utilizado varias variables hardcoded para inicializar el plugin, pero es recomendable dejar toda la libertad posible al usuario y no forzarle a utilizar un nombre de clase CSS concreto, por ejemplo. Para ello, pasaremos al plugin un objeto por parámetro a la hora de inicializarlo con aquellas variables que deseemos permitir modificar.

Source code

(function( $ ){
  $(function() {
    $('input:text').watermark({
    	className: 'marcaDeAgua'
    });
  });
 
  $.fn.watermark = function(options) {
 
  	// establecemos las opciones por defecto
	var defaults = {
    	  className: 'watermark',
    	  attrName: 'title'
	}; 
 
  	// Se sobreescriben las opciones por defecto
	// con las que proporciona el usuario y se
	// combinan en la variable 'options'
  	var options = $.extend({}, defaults, options); 
 
        this.addClass(options.className);
        this.each(function(){
          $(this).val($(this).attr(options.attrName));
        });
  };
})( jQuery );

En el ejemplo anterior le pasamos a la función del plugin un objeto con un único atributo, ‘className‘. En el cuerpo de la función, hemos creado un objeto con dos atributos, que definen el nombre de la clase que utilizarán los input con marca de agua y el atributo de donde cogerán el texto por defecto. En nuestro caso, el ‘title‘.

La potencia del código está en la función siguiente:

$.extend({}, defaults, options);

Esta función, propia de jQuery, nos permite combinar los elementos de un objeto en otro. De este modo, se toma como base el objeto defaults y se sobreescriben los atributos que se han definido en options. Como no hemos definido ningún atributo nuevo del cual coger el texto por defecto, se quedará con el que está predeterminado. En el caso del className, se reemplazará el valor por defecto por el que hemos definido. Podéis comprobarlo ejecutando el código.

Añade eventos

El texto por defecto puede ser útil, pero es bastante molesto tener que borrarlo cada vez que queramos escribir en una caja de texto, ¿verdad? Bien, pues ¡para eso tenemos el código! Vamos a añadir un par de eventos útiles para que se limpie el texto al hacer clic con el ratón y se vuelva a rellenar el contenido por defecto, siempre que el usuario no haya escrito nada.

Source code

this.each(function(){
      $(this).val($(this).attr(options.attrName));
 
      // Implementamos el comportamiento
      // de varios eventos útiles
      $(this).click(function(){
        if($(this).val() == $(this).attr(options.attrName))
                $(this).val('');
      });
 
      $(this).focusout(function(){
      	if($(this).val() == '')
      		$(this).val($(this).attr(options.attrName));
      });
    });

Conclusiones

Hemos creado un plugin que ofrece un comportamiento muy sencillo, para centrarnos en lo que se requiere para hacer un plugin con jQuery y extrapolarlo a cualquier otro comportamiento que deseemos implementar.

Es importante pensar siempre en utilizar eventos para tener controlado el comportamiento del plugin en todo momento, así como usar opciones por defecto para permitir al usuario el poder personalizarlo por completo.

En fin, espero que os haya sido útil. Si tenéis alguna sugerencia para mejorar lo que he descrito, espero vuestros comentarios.

Últimamente ya no escribo, así que no utilizo tanto el ordenador en casa como antes. Pero ella lo necesitaba para buscar trabajo, así que decidimos comprar uno para los dos. En lugar de destinar los ahorros a dos PC’s regularcillos, quisimos echar el resto y comprar algo en condiciones.

El caso es que después de mirar en varias tiendas, todos los ordenadores nos parecían demasiado caros para lo que ofrecían. Estuve incluso mirando de montar uno por piezas, pero me daba mucha pereza volver a tener un sobremesa debajo del escritorio. Por no hablar de que en cualquier tienda te intentan colar una configuración “para poder tirar con el Crysis sin problemas” cuando yo lo único que necesito es que me abra el Google Chrome y el jDownloader. Cuando les digo eso a los dependientes, me miran con cara de haberme visto salir de la alcantarilla remojado en las heces de todo el barrio.

El caso es que fuimos a la Apple Store que hay en el Centro Comercial de La Maquinista a echar un vistazo. No íbamos demasiado convencidos, pero lo que vimos nos impresionó tanto que acabamos por llevarnos uno a casa. Estas tiendas están diseñadas para fardar. Al lado de cada producto tienen un iPad con las especificaciones y una comparativa de las características con otros productos de la familia. A eso se le llama ahorrar papel con clase. Además, tienen un botón con el que llamar al dependiente asignado a esa zona. Nada más pulsarlo, viene a atenderte y a intentar venderte lo que sea.

A nosotros no nos convencía el tema de ver películas y series en la tele. Con el anterior PC lo teníamos bastante bien montado, ya que la Xbox 360 se conectaba al Windows Media Center y se lo tragaba todo. Podíamos ver cualquier cosa por streaming. Preguntamos si había algo parecido para Mac y nos mostraron el Apple TV. Un pequeño cacharrito con salida HDMI y un mando diminuto que se conecta a tus librerías de iTunes y con el que se pueden ver películas, series, fotos o escuchar música. Por el precio que tiene (alrededor de 100€, si no recuerdo mal), vale mucho la pena. Sobre todo, porque nos lo llevamos del salón al dormitorio cuando queremos y vemos lo que nos da la gana con total comodidad.

Lo único que le falta al Apple TV es reproducir DivX, Xvid, Mkv… y esos formatos que todos conocemos. En teoría está diseñado para ver las películas descargadas desde iTunes (o alquiladas desde el propio reproductor, que también tiene ese servicio), pero como la comunidad de usuarios no es tonta se puede jailbreakear para meterle un programita que libere el potencial oculto del chisme y se pueda reproducir de todo. Y si no, siempre puedes convertirlos a un formato compatible nada más bajártelos. Allá tú.

El caso es que estamos encantados con el pack iMac + Apple TV. Mira que yo me gano la vida programando en entorno Microsoft, pero desde que probé el Mac OS he llegado a la conclusión de que he vivido engañado toda mi vida. Facilidad de uso, comodidad, sencillez, diseño, rapidez… todo le da veinte patadas a Windows en cualquier punto comparable. Lo único que echo de menos son los juegos, que no hay demasiados (aunque haberlos, haylos). Pero por lo demás, he estado haciendo el tonto. Probar Mac OS viniendo de Windows es como probar un coche automático viniendo de uno de marchas. Te preguntas por qué narices no se fabrican todos los coches así y qué sentido tiene tener que aprender a usar un embrague y una palanca de cambios en pleno 2011.

Lo que más me ha gustado es una tableta táctil que venden ahora con los iMac. Puedes escoger entre el ratón de toda la vida (de diseño Apple, eso sí) o el bautizado como Magic Trackpad. Es algo así como el área táctil de todos los portátiles, pero para escritorio. La gran ventaja es que es multitáctil, por lo que es capaz de distinguir cuándo la pulsas con varios dedos. Unido a las posibilidades del sistema operativo, es la mejor interfaz para controlar un ordenador que he utilizado en mi vida. El Mac OS reconoce gestos que hacemos con los dedos en el trackpad, por lo que con dos dedos haremos scroll en las páginas web (horizontal o vertical), con tres dedos podemos ir hacia atrás o pasar fotos, también podemos hacer el gesto de ampliar, despejar el escritorio con cuatro dedos… todo completamente configurable. Si esto se incorpora en el mundo Windows, el ratón tiene los días contados.

En fin, que estamos muy contentos. Obviamente, no todo es como te lo venden. Te dicen que Mac OS no se cuelga, no tiene virus, no te irá nunca lento… y no es cierto. Se cuelga, te va lento si tienes demasiadas cosas abiertas y, si bien es cierto que el 90% de los virus existentes no le afectan (por estar programados para Windows), también hay virus para Mac y hay que andarse con ojo. Pero por lo demás, vale mucho la pena para cualquier usuario que quiera el ordenador para cualquier cosa que no sea jugar.

Eso sí, habrá que mirarse un portátil o algo. Ahora tenemos que pedir hora para usarlo

En realidad se trata de un principio que tiene validez en cualquier ámbito de la vida. Tiene distintas variantes y quizás la más conocida es la de la Navaja de Ockham. La solución más sencilla suele ser la correcta. En programación, una codificación sencilla, breve y limpia siempre será más óptima que otra más complicada y elaborada. En un diseño web, eliminar los elementos innecesarios de la interfaz para hacerla lo más usable posible es un trabajo constante de iteración y reflexión.

Si las tendencias en el diseño web se dirigen cada vez más al minimalismo es precisamente para intentar buscar la mínima expresión de lo que se quiere transmitir de la forma más sencilla. En el Románico, la literatura estaba relegada a los textos religiosos y sólo se copiaban libros en los monasterios, con aquellas tipografías germánicas tan recargadas y antinaturales. Con la llegada de la imprenta, la sencillez se abrió camino y los garabatos de los monjes dejaron paso al espacio en blanco y la prosa moderna.

Lo más sencillo siempre es mejor, aunque cueste dar con ello. Intento tenerlo siempre presente.

Notepad++

Descarga: Notepad++

Características

Notepad++ es un editor texto de código abierto, además de gratuito. Funciona sobre Windows, algo que puede echar atrás a los que utilicen otro sistema operativo. Pero en mi caso, ya me va bien.

Entre otras opciones, es capaz de reconocer el código introducido y destacar las palabras clave por colores, ejecutar macros que habremos grabado previamente y un decente “autocompletar” que, si bien no tirará de la documentación oficial, sí que nos ahorrará unos valiosos segundos a la hora de codificar. Otras de sus características son más curiosas que útiles, como el reconocimiento de gestos del ratón para manejar las pestañas. Echo de menos un buen comparador de código, pero podemos encontrarlo en forma de plugin.

He probado otros editores, pero siempre me han parecido demasiado complejos y he terminado volviendo a Notepad++, con el que ya llevo unos años. De todas formas, si conocéis otro mejor, estoy abierto a sugerencias.

Descarga: Notepad++