Hace un par de meses un cliente solicitó esta funcionalidad, entonces comencé a evaluar cómo implementarla. La primera opción fue mediante código de servidor, pero la descarté rápidamente ya que es carga de procesamiento injustificada ya que se puede realizar sin ninguna dificultad en el cliente mediante javascript.

Una vez decidida la forma de implementación… manos a la obra!

El javascript realiza el cambio de fuente mediante el cambio de clase (la etiqueta class) del body y almacena en una cookie los datos para persistir el cambio en el resto te las páginas y en las visitas futuras.

// Area de configuracion ---------------------------------------------------->
var fontSizeCookieName       = "mySiteFontSize"; //El nombre de la cookie
var fontSizeDefaultSize      = 2; // Id del tamaño por defecto
var fontSizeActiveClassName  = "active"; // Class css para el  activo
var fontSizeIdText           = "fontSize"; // Texto previo al id de la fuente
var fontSizeBodyClass        = "fontSize"; // Texto previo al id de la fuente para el class del Css class de
var fontSizeBodyDefaultClass = ""; //  class cuando está activada la fuente por defecto
var fontSizeCookieDuration   = 31; // Tiempo de duración de la cookie, en dias (si se quiere solo para la sesion actual, utilizar 0)
// <----------------------------------------------------------------------

var fontSize;
function getFontSizeCookieValue() {
    var results = document.cookie.match('(^|;) ?' + fontSizeCookieName + '=([^;]*)(;|$)');

    if (results)
        return (unescape(results[2]));
    else
        return null;
}
function deleteFontSizeCookie() {
    var cookie_date = new Date();
    cookie_date.setTime(cookie_date.getTime() - 1);
    document.cookie = fontSizeCookieName += "=; expires=" + cookie_date.toGMTString();
}
function setFontSizeCookie(size) {
    if (fontSizeCookieDuration != 0) {
        var current_date = new Date;
        var cookie_year = current_date.getFullYear();
        var cookie_month = current_date.getMonth();
        var cookie_day = current_date.getDate() + fontSizeCookieDuration;

        var cookie_string = fontSizeCookieName + "=" + escape(size);

        if (cookie_year) {
            var expires = new Date(cookie_year, cookie_month, cookie_day);
            cookie_string += "; expires=" + expires.toGMTString();
        }
    }

    cookie_string += "; path=/";

    document.cookie = cookie_string;
}
function setFontSize(size) {
    if (size != fontSizeDefaultSize) {
        document.body.className = fontSizeBodyClass + size;
    } else {
        document.body.className = fontSizeBodyDefaultClass;
    }
    fontSize = size;
}
// Cambia el tamaño, setea el link activo y actualiza la cookie
function changeFontSize(sizeAnchor) {
    if (sizeAnchor.id) {
        var size = sizeAnchor.id;
        size = size.substring(8);
        document.getElementById(fontSizeIdText + fontSize).className = "";
        setFontSize(size);
        setFontSizeCookie(size);
        sizeAnchor.className = fontSizeActiveClassName;
    }
}
// Funcion inicializadora
function fontSizeInit() {
    // Obtiene la cookie, si no existe, la crea
    if (!getFontSizeCookieValue()) {
        setFontSizeCookie(fontSizeDefaultSize);
        fontSize = fontSizeDefaultSize;
    }
    else {
        fontSize = getFontSizeCookieValue();
    }

    changeFontSize(document.getElementById(fontSizeIdText + fontSize));
}
// Colocar la funcion inicializadora en el onLoad porque el elemento  no está disponible hasta que la página carge y daría error
window.onload = fontSizeInit;

Los enlaces “A” deben de llamar a changeFontSize(this) y deben de tener como id “fontSizeX” donde X es el id del class por la cual se cambiará el del body.

Microsoft, en su lucha por seguir en el podio, nos trae ahora una propuesta novedosa y muy muy interesante, es lo que necesitamos para evitar todos estos dolores de cabeza…

Live Mesh, que en su sitio web se define como “una herramienta capaz de sincronizar archivos con todos los tus dispositivos, de modo de tener siempre la última versión al alcance de la mano; también permite acceder a tus archivos a través de la web, compartirlos con otros y ser notificado cuando alguien cambia alguno de ellos”.
Esta descripción suena maravillosa… pero realmente es así?

La prueba

He estado utilizando live Mesh en dos equipos desde hace 3 meses. Lo utilizo para compartir archivos de trabajo que siempre necesito tener a mano (uno nunca sabe cuando un cliente le va a hacer una petición desesperada).

La configuración fue extremadamente sencilla:

1. Registro en el sitio http://www.mesh.com
2. Agregar un nuevo equipo
3. Descargar el instalador para la versión de windows adecuada
4. Instalarlo en la máquina a sincronizar

Una vez instalado, se ejecutará y nos solicitará nombre de usuario y contraseña. Una vez ingresados estos datos, ya estaremos logueados en el mesh.
Podremos visualizar en el panel de tareas un ícono (Imágen 1), si ponemos el puntero del mouse sobre éste, veremos que se desplega un panel indicandonos todos los equipos que pertenecen al Mesh junto con su estado actual. También nos incluye el Live Desktop que veremos más adelante.

Imágen 1 - Panel de tareas

En este mismo panel podremos ver también Noticias (Imágen 2) y los Directorios que actualmente se encuentran sincronizados (Imágen 3)

Imágen 2 - Noticias

Imágen 3 - Directorios compartidos

¿Cómo sincronizar un directorio?

Es muy sencillo, simplemente le hacemos click con el botón derecho del ratón sobre el directorio a sincronizar y en el menú contextual seleccionamos “Agregar a Live Mesh” (Imágen 4).

Imágen 4 - Sincronizar un directorio

Se desplegará un panel con opciones (Imágen 5). Debemos especificar el nombre del directorio y la forma en que sincronizará con los distintos dispositivos.

Imágen 5 - Opciones de sincronización

Una vez hecho esto, el directorio quedará con el ícono que se muestra en la Imágen 6, indicándonos que se encuentra en nuestro Live mesh.

Imágen 6 - Directorio sincronizado

Si ingresamos ahora al directorio ya sincronizado, veremos que se despliega un panel con opciones de Live Mesh (Imágen 7). Este panel nos mostrará en primera instancia, las noticias relacionadas con este directorio.

Imágen 7 - Panel de directorio

Dentro de este mismo panel, también podremos visualizar los usuarios que pueden visualizar todo el contenido de este directorio, agregar nuevos, moficiar los existentes o eliminarlos (Imágen 8). Por último, este panel también nos informa de los dispositivos con los cuales se está sincronizando el directorio (Imágen 9) y nos permite administrarlos.

Imágen 8 - Panel de directorio - Usuarios

Imágen 9 - Panel de directorio - Dispositivos

Live Desktop

Hasta ahora todo va perfecto… sin embargo… ¿qué pasa si necesitamos algún archivo y no estamos en una máquina sincronizada?. No os preocupeis, todo está pensado.
Si accedemos via web a www.mesh.com Veremos dentro de nuestros dispositivos un “Live Desktop” (Imágen 10) que no es ni más ni menos que un “dispositivo” que nos permite ver los directorios y los archivos que tenemos sincronizados.

Imágen 10 - Live Desktop

La interfaz es expectacular, una perfecta simulación de windows, ¡y además podemos acceder utilizando cualquier navegador! (Imágen 11)

Imágen 11 - Live Desktop Directorio

Live Mesh Remote Desktop

Para concluir con este reporte (y sin dejar de dar importancia) tenemos la última característica; la posibilidad de conectarnos por escritorio remoto a alguno de los dispositivos que se encuentre conectado al mesh (imagino no es necesario aclarar que dicho dispositivo debe de estar encendido, conectado a internet y con el live mesh en ejecución).

Para conectarnos, simplemente presionamos sobre el enlace “Conectar con el dispositivo” (Imágen 12).

Imágen 12 - Conect to device

Se nos desplegará una ventana muy similar al típico Escritorio Remoto de windows (mstsc) en la cual veremos la pantalla “tal como si estuvieramos sentados en frente” (Imágen 13)

Imágen 13 - Live Mesh Remote Desktop

Resúmen – Conclusión

Una verdadera novedad por parte de Microsoft; super útil, fácil de usar y ágil. Es la perfecta solución para todos los que usamos varios equipos y debemos de tener archivos sincronizados y siempre disponibles (y somos demasiado despistados y desprolijos como para utilizar un pendrive). La única desventaja es que por el momento solo tienen 5GB de capacidad, lo que significa que la suma de todos los archivos de todos los directorios sincronizados no puede superar esta cantidad.

Les recomiendo totalmente que usen esta herramienta!.

Sistemas en los que realicé la prueba: Windows XP SP3, Windows Vista SP1 (actualmente SP2)

Esta novedosa API nos permite incluir datos obtenidos por Google Analytics en nuestras aplicaciones.

¿De qué sirve esto?

De mucho. Nos podemos imáginar infinidades de usos; desde la simple colocación de datos en nuestro CMS hasta la creación de una nube de tags.

Mi experiencia personal fue la colocación en el CMS de la empresa en la que trabajo, con un muy pintoresco resultado:

El desafío

Ya que nuestro CMS está basado en .NET, y dado el poco soporte que Google brinda a esta plataforma, implementé mi propia clase para obtener datos.
Esta clase se encarga de convertir las feeds XML que envía google en una estructura mucho más práctica y fácil de usar en .NET: el DataTable.

Es de fácil uso y está comentada para que se pueda entender con facilidad. De todas maneras es conveniente que estudien un poco el prototipo que expone Google para la exportación de datos: http://code.google.com/apis/analytics/docs/gdata/1.0/gdataProtocol.html

Para realizar las consultas deben de tener en cuenta las dimensiones y métricas que son las que nos permiten seleccionar qué datos queremos traer; por ejemplo le podemos decir que queremos la dimensión ga:pagePath y la métrica ga:pageviews lo que nos daría como resultado, la cantidad de visitas que tuvo cada una de las páginas de nuestro sitio. Otro ejemplo más sencillo sería obtener las visitas totales que tuvo nuestro sitio por fecha, esto lo podemos lograr utilizando la dimensión ga:date y la métrica ga:visits

¿Cómo comienzo a utilizarlo?

1. En Visual Studio agregamos la clase a nuestra librería.
2. Analizamos qué datos queremos obtener en el DataTable.
3. Creamos la consulta basandonos en las métricas, dimensiones, filtrados, etc…
4. Llamamos al método GetData() enviándole como parámetros la consulta.
5. Obtenemos un DataTable que podemos utilizar como queramos.

Ejemplos de llamados al método:

• Para obtener las visitas al sítio por día del último mes ordenadas por fecha asc:
  DataTable data = GetData(new string[] { “ga:date” }, new string[] { “ga:visits” }, new string[] { “ga:date” }, new string[] { }, DateTime.Today.AddMonths(-1), DateTime.Today, 0, 0);
• Para obtener la fuente de las visitas (de donde llegan a nuestro sitio) del último mes ordenado por fuente:
  DataTable data = GetData(new string[] { “ga:source” }, new string[] { “ga:visits” }, new string[] { “ga:source” }, new string[] { }, DateTime.Today.AddMonths(-1), DateTime.Today, 0, 0);
• Para obtener la cantidad de visitas que tuvo cada página de nuestro sitio en el último mes ordenado por cantidad de visitas desc:
  DataTable data = GetData(new string[] { “ga:pagePath” }, new string[] { “ga:pageviews” }, new string[] { “-ga:pageviews” }, new string[] { }, DateTime.Today.AddMonths(-1), DateTime.Today, 0, 0);

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using System.Net;
using System.Xml;
using System.Data;

public class GAnalytics
{
    #region Atributos

    private string _username = null;
    private string _password = null;
    private string _profileId = null;
    private string _token = null;
    private static readonly string authUrlFormat = "accountType=GOOGLE&Email={0}&Passwd={1}&source=reimers.dk-analyticsreader-0.1&service=analytics";

    #endregion

    public GAnalytics() { }

    public GAnalytics(string username, string password)
    {
        _username = username;
        _password = password;
    }

    public GAnalytics(string username, string password, string profileId)
    {
        _username  = username;
        _password  = password;
        _profileId = profileId;
    }

    #region Properties

    public string Username
    {
        get
        {
            return _username;
        }
        set
        {
            _username = value;
        }
    }

    public string Password
    {
        get
        {
            return _password;
        }
        set
        {
            _password = value;
        }
    }

    public string Token
    {
        get
        {
            if (string.IsNullOrEmpty(_token))
            {
                _token = GetToken();
            }
            return _token;
        }
    }

    public string ProfileId
    {
        get
        {
            return _profileId;
        }
        set
        {
            _profileId = value;
        }
    }

    #endregion

    #region Metodos

    ///
    /// Loguea al usuario en Google y obtiene el Token
    ///
    ///
    private string GetToken()
    {
        try
        {
            if (string.IsNullOrEmpty(Username) || string.IsNullOrEmpty(Password))
            {
                throw new ArgumentNullException("Username, Password", "Username and/or password not set");
            }

            string authBody = string.Format(authUrlFormat, Username, Password);
            HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create("https://www.google.com/accounts/ClientLogin");
            req.Method = "POST";
            req.ContentType = "application/x-www-form-urlencoded";
            req.UserAgent = "CSharp Application";
            Stream stream = req.GetRequestStream();
            StreamWriter sw = new StreamWriter(stream);
            sw.Write(authBody);
            sw.Close();
            sw.Dispose();
            HttpWebResponse response = (HttpWebResponse)req.GetResponse();
            StreamReader sr = new StreamReader(response.GetResponseStream());
            string token = sr.ReadToEnd();
            string[] tokens = token.Split(new string[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string item in tokens)
            {
                if (item.StartsWith("Auth="))
                {
                    return item.Replace("Auth=", "");
                }
            }
        }
        catch (Exception e)
        {
            throw (e);
        }
        return string.Empty;
    }

    ///
    /// Parsea la fecha en formato DateTime
    ///
    ///
Fecha en formato yyyy-mm-dd
    ///
    private DateTime ParseDate(string date)
    {
        return new DateTime(int.Parse(date.Substring(0, 4)), int.Parse(date.Substring(4, 2)), int.Parse(date.Substring(6, 2)));
    }

    ///
    /// Parsea un documento xml en una DataTable.
    ///
    ///
Documento XML retornado por el servidor
    ///
Dimensiones de la petición
    ///
Métricas de la petición
    ///
    private DataTable ParseXml(XmlDocument xml, string[] dimensions, string[] metrics)
    {
        DataTable data = new DataTable();
        foreach (string dimension in dimensions)
        {
            if (dimension == "ga:date")
            {
                data.Columns.Add(dimension, typeof(DateTime));
            }
            else
            {
                data.Columns.Add(dimension);
            }
        }
        foreach (string metric in metrics)
        {
            data.Columns.Add(metric);
        }

        foreach (XmlNode node in xml.ChildNodes[1])
        {
            if (node.Name.Equals("entry", StringComparison.CurrentCulture))
            {
                DataRow row = data.NewRow();
                foreach (XmlNode nodeValue in node.ChildNodes)
                {
                    if (nodeValue.Attributes["name"] != null)
                    {
                        foreach (string dimension in dimensions)
                        {
                            if (nodeValue.Attributes["name"].Value == dimension)
                            {
                                if (dimension == "ga:date")
                                {
                                    row[dimension] = ParseDate(nodeValue.Attributes["value"].Value);
                                }
                                else
                                {
                                    row[dimension] = nodeValue.Attributes["value"].Value;
                                }
                            }
                        }
                        foreach (string metric in metrics)
                        {
                            if (nodeValue.Attributes["name"].Value == metric)
                            {
                                row[metric] = nodeValue.Attributes["value"].Value;
                            }
                        }
                    }
                }
                data.Rows.Add(row);
            }
        }
        return data;
    }

    ///
    /// Perfiles a los cuales tiene acceso el usuario
    ///
    ///
    public NameValueCollection GetProfiles()
    {
        //Obtengo la respuesta
        string response = GetResponse("https://www.google.com/analytics/feeds/accounts/default");

        //Obtengo el nodo correspondiente con los perfiles sobre los cuales el usuario tienen permisos
        XmlDocument accountinfoXML = new XmlDocument();
        accountinfoXML.LoadXml(response);
        XmlNodeList entries = accountinfoXML.GetElementsByTagName("entry");

        //Cargo los perfiles
        NameValueCollection profiles = new NameValueCollection();
        for (int i = 0; i < entries.Count; i++)
        {
            profiles.Add(entries.Item(i).ChildNodes[2].InnerText, entries.Item(i).ChildNodes[7].Attributes["value"].Value);
        }

        return profiles;
    }

    //Atajo sin ProfileId
    public DataTable GetData(string[] dimensions, string[] metrics, string[] sort, string[] filters, DateTime startDate, DateTime endDate, int resultLimit, int pageIndex)
    {
        return GetData(dimensions, metrics, sort, filters, startDate, endDate, resultLimit, pageIndex, ProfileId);
    }

    ///
    /// Retorna un DataTable con los resultados para los parametros indicados.
    ///
    ///
Optional. Specifies the dimensions included in the report and by which metrics will be segmented. A single request is limited to a maximum of 7 dimensions.
    /// dimensions=ga:country,ga:browser. For more information, see http://code.google.com/apis/analytics/docs/gdata/1.0/gdataProtocol.html#requestingDimensions
    ///
Optional.Specifies the metrics included in the report. A single request is limited to a maximum of 10 metrics.
    /// metrics=ga:pageviews,ga:uniquePageviews. For more information, see http://code.google.com/apis/analytics/docs/gdata/1.0/gdataProtocol.html#requestingMetrics
    ///
Optional. Specifies sort order and direction for the entries in the feed.
    /// sort=ga:browser,ga:pageviews. For more information, see http://code.google.com/apis/analytics/docs/gdata/1.0/gdataProtocol.html#sorting
    ///
Optional. Specifies filters to apply to the data in your profile to return a sub-set of entries. filters=ga:country%3D%3DCanada
    /// For more information, see http://code.google.com/apis/analytics/docs/gdata/1.0/gdataProtocol.html#filtering
    ///
Required. All Analytics feed requests must specify a beginning and ending date range. If you do not indicate start- and end-date values for the request, the server will return a 400 Bad request error. Date values are in the form YYYY-MM-DD. See Common Query Parameters for more details. start-date=2008-07-22 end-date=2008-08-22
    ///
Required. All Analytics feed requests must specify a beginning and ending date range. If you do not indicate start- and end-date values for the request, the server will return a 400 Bad request error. Date values are in the form YYYY-MM-DD. See Common Query Parameters for more details. start-date=2008-07-22 end-date=2008-08-22
    ///
To manipulate the result set for a large number of entries, you can use max-results parameter. Value between 0 and 1000. Use it in 0 to get all enteries
    ///
Número de página de la cual se quiere mostrar el resultado. 0 para todas
    ///

    /// Datatable con todos los resultados
    public DataTable GetData(string[] dimensions, string[] metrics, string[] sort, string[] filters, DateTime startDate, DateTime endDate, int resultLimit, int pageIndex, string profileId)
    {
        if (string.IsNullOrEmpty(profileId))
        {
            throw new ArgumentNullException("ProfileId cannot be empty");
        }
        if (dimensions.Length == 0 || metrics.Length == 0)
        {
            throw new ArgumentException("There must be at least one dimension and one metric");
        }

        string url = "https://www.google.com/analytics/feeds/data?ids=ga:" + profileId;

        //Agrego las dimensiones
        if (dimensions.Length > 0)
        {
            url += "&dimensions=" + dimensions[0];
            for (int i = 1; i < dimensions.Length; i++)
            {
                url += "," + dimensions[i];
            }
        }

        //Agrego las métricas
        if (metrics.Length > 0)
        {
            url += "&metrics=" + metrics[0];
            for (int i = 1; i < metrics.Length; i++)
            {
                url += "," + metrics[i];
            }
        }

        //Agrego los parámetros de ordenamiento
        if (sort.Length > 0)
        {
            url += "&sort=" + sort[0];
            for (int i = 1; i < sort.Length; i++)
            {
                url += "," + sort[i];
            }
        }

        //Agrego los parámetros de filtrado
        if (filters.Length > 0)
        {
            url += "&filters=" + filters[0];
            for (int i = 1; i < filters.Length; i++)
            {
                url += "," + filters[i];
            }
        }

        //Agrego el rango de fechas
        url += "&start-date=" + startDate.ToString("yyyy-MM-dd");
        url += "&end-date=" + endDate.ToString("yyyy-MM-dd");

        //Agrego la cantidad máxima de filas. Si es 0 el se traerán todos los registros
        if (resultLimit > 0)
        {
            url += "&max-results=" + resultLimit;
        }
        else
        {
            url += "&max-results=1000"; //1000 es el valor máximo de carga permitido por google
        }

        //Si tengo más de una página agrego el número de página
        if (pageIndex > 0)
        {
            url += "&start-index=" + pageIndex;
        }
        else
        {
            url += "&start-index=1";
        }

        //Obtengo el xml de respuesta
        XmlDocument xml = new XmlDocument();
        xml.LoadXml(GetResponse(url));

        int results = GetResultNumber(xml);
        double totalPages = results / 1000;
        totalPages = Math.Ceiling(totalPages);

        //Si quiero todos los resultados y tengo más de una página, llamo recursivamente y mergeo los DataTable
        if (results > 1000 && resultLimit == 0 && pageIndex < totalPages)
        {
            DataTable returnData = ParseXml(xml, dimensions, metrics);
            returnData.Merge(GetData(dimensions, metrics, sort, filters, startDate, endDate, 0, pageIndex + 1, profileId));
            return returnData;
        }
        else
        {
            return ParseXml(xml, dimensions, metrics);
        }
    }

    private int GetResultNumber(XmlDocument xml)
    {
        //Busco el valor del nodo openSearch:totalResults
        foreach (XmlNode node in xml.ChildNodes[1])
        {
            if (node.Name.Equals("openSearch:totalResults", StringComparison.CurrentCulture))
            {
                return int.Parse(node.InnerText);
            }
        }
        return 0;
    }

    ///
    /// Retorna la string de respuesta del servidor
    ///
    ///
URL a la que se debe de realizar la petición
    ///
    private string GetResponse(string url)
    {
        //Creo la petición Http
        HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(url);

        //Agrego la cabecera Http para la autenticación
        myRequest.Headers.Add("Authorization: GoogleLogin auth=" + Token);

        try
        {
            //Intento obtener una respuesta
            HttpWebResponse myResponse = (HttpWebResponse)myRequest.GetResponse();
            Stream responseBody = myResponse.GetResponseStream();

            Encoding encode = System.Text.Encoding.GetEncoding("utf-8");
            StreamReader readStream = new StreamReader(responseBody, encode);
            return readStream.ReadToEnd();
        }
        catch (Exception e)
        {
            throw (e);
        }
    }

    #endregion
}

Estaría bueno que compartieran cualquier correción, upgrade del código.

Fuentes:
http://analytics.blogspot.com/2009_05_01_analytics_archive.html
http://www.akamarketing.com/blog/103-introducing-google-analytics-api-with-aspnet-c.html
http://code.google.com/apis/analytics/docs/gdata/1.0/gdataProtocol.html

Vamos a asumir que ya tenemos instalado el IIS (Internet Information Services ¿Cómo lo instalo?) y el servidor SMTP (lo puedes instalar a través de “Server Manager >Features > SMTP”)

Bien, ahora comenzaremos con la configuración del servidor SMTP.
Ya que este correo es una característica de IIS6, procederemos a ejecutar el administrador del mismo:

Win + R (ó “Inicio > Ejecutar”), escribimos “inetmgr6″ y enter.

Una vez en el administrador, hacemos click derecho sobre “SMTP Server” y seleccionamos “Propiedades” (Imagen 1)

Imagen 1 - IIS Manager

En la ventana de Propiedades, vamos a la pestaña “Delivery”

Imagen 2 - Ventana de propiedades del servidor SMTP

Luego, presionamos el botón “Avanzado” y en el campo “Smart host” colocamos el DNS del servidor real (el que realizará la entrega) de correo.

Imagen 3 - Ventana de configuración avanzada de opciones de entrega del servidor SMTP

Por último, si el servidor real de correo necesita autenticación, nos dirigimos a “Outbound security” (en la pestaña de Delivery) y seleccionamos el modo de autenticación (probablemente “Autenticación Básica” dado que la mayoría de los servidores están basados en sistemas unix) y colocamos nuestro nombre de usuario y contraseña (como en outlook o thinderbird).

Imagen 4 - Opciones de salida del servidor SMTP

Puedes utilizar la configuración que se muestra en las imágenes para utilizar el servidor de GMail.

Tip: Puedes usasarlo con Google Apps con la misma configuración de las imágenes pero colocando como nombre de usuario el correo completo (ejemplo: pepe@suempresa.com).

Finalmente, desinstalé y probé instalar la versión en ingles (tenía la versión en español). Una vez finalizada la instalación, el error todavía seguía. Sin esperanzas abri el cmd y ejecuté “C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE>devenv -ResetSkipPkgs” y voilà, el editor comenzó a funcionar…

Aún nose que fue lo que estaba funcionando mal, supongo que el prolema era que Windows estaba en inglés mientras que Visual Studio en español… Uno más para los misterios sin resolver de Microsoft.

Necesitas un servidor de correo confiable? Una agenda online? y no quieres gastar ni un centésimo? Entonces… Google es la solución.
Con Google Apps tienes GMail, Google Calendar, GTalk, Google Docs, Google Sites, Google Video y mucho más… todo @tudominio y gratis.

Qué necesitas para obtener esto? Primero debes de tener un nombre de dominio con acceso a modificar los registros DNS (como ofrece www.godaddy.com). Luego, accedes a apps.google.com y completas el asistente de registro.

Si ya tienes una cuenta de gmail puedes centralizar todo el tráfico de correos en esa cuenta (lo utilizo y me parece genial). Si usas Outlook o Thunderbird, puedes habilitar el POP (o IMAP) para seguir utilizando el correo como antes.

Google is the best!!!

Si lo que necesitas es probar una configuración de DNS a través del mundo esta herramienta te quitará un peso de encima:
http://www.kloth.net/services/dig.php

También puedes utilizar el tradicional pero efectivo comando nslookup.

Para realizar las consultas, puedes utilizar el servidor por defecto o algun otro. En la siguiente lista puedes encontrar servidores DNS de diferentes partes del mundo:
http://www.dnsserverlist.org/

Ayer, el encargado del área de marketing me pidió que instalara Micrsoft Dynamics CRM en el servidor.
Comencé con la instalación y todo parecía estar yendo bien hasta que el asistente de instalación me notificó un error:  ”Microsoft CRM El programa de instalación no ha podido validar el servidor de informes de Reporting Services especificado Error: This operation is not supported on a report server that is configured to run in SharePoint integrated mode”

Busqué en google una solución para este problema y la única solución era instalar otra instancia de MS SQL Server en otro servidor… No era viable…

Seguí tratando hasta que finalmente encontré la solución al problema:

Abrir el “Reporting Services Configuration” en Inicio > All Programs > Microsoft SQL Server 2008 > Configuration tools > Reporting Services Management and configuration. Una vez ahí, nos conectamos con el servidor y nos dirigimos a “Database” en el menú izquierdo. Clickeamos en Change Database y seleccionamos “Create a new report server database”. Seguimos las instruciones del asistente y listo! Ahora ya podemos instalar Microsoft Dynamics CRM.
Fácil, no?

En esta primera publicación solamente quiero hablar de cuál es el lineamiento general de este blog.
Mi objetivo es compartir conocimiento y experiencias personales con todo el mundo.

Mi nombre es César nicola tengo 19 años y vivo en Uruguay. Estudio ingeniería en computación y trabajo en INSource Soft y también como freelancer.

Bueno, esto es todo,
Muchas gracias por visitar mi blog y espero que sea de tu agrado!
Por cualquier motivo me pueden contactar a través de la página de contacto