Probando Microsoft AZURE

Luego de la espera de 3 días para recibir e acceso a Microsoft AZURE, al fin he logrado probar los servicios realizando conexión desde .net

Luego de registrase, se puede crear la base de datos simplemente como estructura general, pero no se puede aún crear los componentes como tablas, índices, etc.. desde el ambiente proporcionado, para poder crear la estructura se lo debe hacer mediante conexión a la base de datos con .net, php, u otro soportado.

Se proporciona el ConnectionString  para poder ser utilizado, en mi caso desde .net, para lo cual muestro un código muy criollo para la conexión

 

 

 

 

Así mismo todas la configuraciones de firewall se las realiza desde el entorno web proporcionado por AZURE

Espero que el CTP madure, pero ahora mismo ya tenemos con SQL Azure un primer paso para mantener nuestra base de datos.

Cloud Computing

Hablamos mucho en la actualidad de la computación en las nubes, nubes computacionales. Esta tomando mucha fuerza el tema y los más grandes le están apostando a estos servicios ofrecidos en la red que lo que nos permiten es tener servicios que se ejecuten en la red sin necesidad de preocuparnos la infraestructura, ya que esto esta solventado un por una gran arquitectura computacional ofrecido como servicios de terceros. El realizar enlaces de aplicaciones en la red y la comunicación de estas se ha convertido un juego de niños.

Existen muchas aplicaciones ofrecidas mediante este esquema como por ejemplo http://www.salesforce.com/platform/ que nos ofrece CRM online.

Buscando en la red me he encontrado con una plataforma muy interesante, que nos ofrece servicios para publicar nuestras aplicaciones en una nube computacional de la manera mas sencilla, es un conjunto de herramientas basadas en Eclipse llamada Aptana.

Que nos permite crear nuestras aplicaciones de una forma muy sencilla, principalmente basadas en php,ruby, html, ajax, etc…

para tener el servicio de publicación tenemos que pagar, esto es obvio por la infraestructura que se tiene que montar para poder ofrecer los servicio.

Herramienta para bloggear desde Linux

He estado buscando alguna herramienta para poder postear desde linux y me he encontrado con dos herramientas interesantes:

1. BloGTK
#sudo aptitude install blogtk

2. Drivel
#sudo aptitude install drivel

La primera herramienta, he tenido problemas ya que no se ejecuta en mi computador por lo que realmente no la he probado.

La segunda desde la cual estoy escribiendo este post me parfece muy simple y le faltan varias opciones, esa apreciación considerando que he venido de un entorno windows en donde si he tenido variedad de opciones.

Las consideraciones básicas para permitir el funciononamiento con wordpress para cualquiera de las dos herramientas mencionadas son:
– El tipo de Blog System se debe especificar como Movable Type
– La URL del servidor debe ser http://tublog.wordpress.com/xmlrpc.php, no olvides agregar /xmlrpc.php, ya que esto te permite realizar la conexión de manera satisfactoria.

Historia del Programador

1. Al principio Dios creo el Bit y el Byte. Y de ellos creo la Palabra.
2. Y hubo dos bytes en una palabra; y nada mas existía. Y Dios separo el Uno del Cero; y vio que esto era bueno.
3. Y Dios dijo: – Hágase el Dato.
Y así sucedió.
Y Dios dijo: – Que los Datos vayan a su correspondiente lugar.
Y creo los disquetes, discos duros y los compactos.
4. Y dijo Dios: – Háganse los computadores, así habrá lugar para poner los disquetes, discos duros y compactos.
Y Dios creo los computadores y los llamó Hardware.
5. Y no había Software aun. Pero Dios creo programas, chicos y grandes…
Y les dijo: – Vayan y multiplíquense por si mismos y llenen toda la Memoria.
6. Y dijo Dios: – Creare al Programador; y el Programador hará nuevos programas y gobernara sobre los computadores, programas y datos.
7. Y Dios creo al Programador y lo puso en el Centro de Datos.
Y Dios le mostró al Programador el Árbol de Directorios y le dijo: – Puedes usar todos los volúmenes y subvolumenes, pero ¡NO USES! Windows.
8. Y Dios dijo: – No es bueno para el Programador estar solo.
Y tomo un hueso del cuerpo del Programador y creo una criatura que buscaría al Programador, lo admiraría y amaría las cosas que hiciera el Programador; Y Dios llamo a la criatura EL USUARIO.
9. Y el Programador y el Usuario fueron dejados por EL solos bajo el DOS desnudo y fue bueno.
10. Pero Bill fue mas listo que todas las otras criaturas de Dios.
Y Bill le dijo al Usuario: – ¿Realmente Dios te dijo que no ejecutaras ningún programa?
11. Y respondió el Usuario. – Dios nos dijo que podíamos usar cualquier programa y cualquier dato pero nos dijo que no ejecutáramos Windows o moriríamos.
12. Y Bill dijo al Usuario – ¿Cómo puedes hablar sobre algo que no has probado? En el momento que corras Windows te convertirás en igual a Dios. Podrás crear cualquier cosa que desees con un simple clic del ratón?
13. Y el Usuario vio que los frutos del Windows eran buenos y fáciles de usar. Y el Usuario vio que cualquier conocimiento era inútil, pues Windows podía reemplazarlos.
14. Así que el Usuario instalo Windows en su computador y le dijo al Programador que era bueno.
15. Y el Programador empezó a buscar nuevos drivers.
Y Dios le pregunto: – ¿Qué buscas?
Y el Programador respondió: – Busco nuevos drivers porque no puedo hallarlos en el DOS.
Y Dios dijo: – ¿Quien te dijo que necesitabas drivers? ¿Ejecutaste Windows?
Y el Programador dijo: – ¡Fue Bill quien nos lo dijo!
16. Y Dios dijo a Bill: – Por lo que hiciste serás odiado por todas las criaturas.
Y el Usuario estará siempre descontento contigo.
Y siempre venderás Windows.
17. Y Dios dijo al Usuario – Por lo que hiciste Windows te decepcionara y se comerá todos tus recursos.
Y tendrás que usar programas piojosos.
Y siempre confiaras en la ayuda del Programador.
18. Y Dios dijo al Programador: – Porque oíste al Usuario nunca serás feliz. Todos tus programas tendrán errores y tendrás que arreglarlos hasta el fin de los tiempos.
19. Y Dios los echo del Centro de Datos y cerro la puerta y la aseguró con un password.
20. FALLA DE PROTECCION GENERAL – Apriete Ctrl-Alt-Del

Patron creacional Singleton

Dentro del conjunto de patrones creacionales uno de los más sencillo de entender e implementar es el singleton.

Propósito

Garantizar que solo se tenga una instancia y maneter un punto de acceso global a ella

Motivación: Muchas ocasiones necesitamos que de una determinada clase únicamente se pueda crear una sola instancia, en mi experiencia muy particular le he encontrado mucha utilidad en las aplicaciones móviles. Cuando tenemos una form creado en .net para dispositivo móvil este se crea con una x en la esquina, el cual no precisamente cierra la venta al hacerle click lo que ocasiona que si nuevamente llamamos al menú que despliega esta ventana nos creará otra instancia lo cual no es recomendable en aplicaciones móviles ya que la memoria tiende a saturarse, al implementar este patron lo que hariamos es mantener una sola instancia y al invocar nuevamente el form lo que hariamos es simplemente reactivar el formulario.

Estructura:

Participantes:

• Singleton: Define la operación instancia que permite que se acceda a la instancia, esta es static.

Implementación:

¿Como sincronizar datos en aplicaciones móviles con .net?

Este tema de sincronización de datos en las aplicaciones móviles es el que posiblemente  nos hace doler la cabeza al momento de desarrollar una aplicación móvil.

Existen varios mecanismos de sincronización como son:

• RDA: Mecanismo de sincronización de datos cuando utilizas sql server para lo cual utilizas la clase SqlCeRemoteDataAccess, para lo que deberias tener sql server tanto en el dispositivo móvil como en el servidor. Si deseas utilizar otra base de datos en el servidor puedes utilizar Microsoft SQL Server 2005 Compact Edition Access Database Synchronizer, este te permite la sincronización con base de datos access. Link de descarga
• Servicios Web(XML, REST): Podrias levantar un conjunto de servicios web los cuales los consumes desde el dispositvo móvil tanto para entrada de datos como para la salida
• Entornos desconectados XML: Si deseas mantener independencia de cualquiera de las partes y manejar un entorno desconectado la mejor opción seria XML ya que lo puedes manejar las carga y descargas estos pueden ser administrados a través del SD de tu dispositivo.
• GPRS, podria ser otra alternativa manejar flujos de información mediante la red de la telefónica pero ahi muchos puntos que evaluar aun.
• Implementar servicios de red mediante sockets, suena bien pero gran trabajo por hacer.

Elegir la mejor alternativa depende del contexto en el cual estemos trabajando pero los medios son varios

ParrallelFX

Son las nuevas extensiones de .net para soporte multicore o multiprocesamiento. En la actualidad tenemos los famosos procesadores multicore pero como podemos utilizarlos de manera adecuada desde nuestro código?.

Que interesante poder escribir cosas como estas

Parallel.For(0, 100, delegate(int i) {
  a[ i ] = a[ i ] * a[ i ];
});

Las nuevas extensión funcionan sobre el famework 3.5, ahi les dejo el link en donde pueden encontrar mas información

http://msdn2.microsoft.com/en-us/concurrency/default.aspx

Configurando el Project Web Access

Como agregación al post de configuración de project server el último paso que falta es la configuración del pwa,  la pantalla de configuración es la siguiente

Como datos relevantes se tienen el sharepoint web application que debemos especificar, luego el servidor primario de base datos, damos aceptar y esperamos a que se cree el pwa esto demora unos minutos y quedará listo.

Patrones Creacionales

 

Los patrones creaciones abstraen el proceso de instanciación y hacen que el sistema sea independiente de la creación de los objetos.

Dentro de los patrones creacionales se tiene:

Abstract Factory

Permite la creación de familias de objetos relacionados que dependen entre si.

Motivación: La motivación para la creación de este patróo es a aceptación de multiples presentaciones de usuario, por ejemplo vamos a suponer que deseamos construir una aplicación en la que necesitemos tener diferentes look and feel entonces se lo puede solocionar por medio de este patron.

Estructura:

Participantes:

• Fabrica Abstracta: Declara una interfaz para operaciones que crean objetos de producto abstracto
• FabricaConcreta: Implementa las operaciones para crear objetos producto concreto
• ProductoAbstracto: Declara una interfaz para un tipo de objeto producto
• ProductoConcreto: Define un objeto producto para que sea creado por la fabrica correspondiente
• Cliente: Usa las interfaces de FabricaAbstracta y ProductoAbstracto

Implementación c#

using System;

namespace Patterns.Creational
{
    class AbstractFactoryPattern
    {
        public static void Main()
        {
            // Abstract factory #1 
            AbstractFactory factory1 = new ConcreteFactory1();
            Client c1 = new Client(factory1);
            c1.Run();

            // Abstract factory #2 
            AbstractFactory factory2 = new ConcreteFactory2();
            Client c2 = new Client(factory2);
            c2.Run();

            // Wait for user input 
            Console.Read();
        }
    }

    // "AbstractFactory" 

    abstract class AbstractFactory
    {
        public abstract AbstractProductA CreateProductA();
        public abstract AbstractProductB CreateProductB();
    }

    // "ConcreteFactory1" 

    class ConcreteFactory1 : AbstractFactory
    {
        public ConcreteFactory1()
        {
            int a = 1;
        }
        public override AbstractProductA CreateProductA()
        {
            return new ProductA1();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB1();
        }
    }

    // "ConcreteFactory2" 

    class ConcreteFactory2 : AbstractFactory
    {
        public override AbstractProductA CreateProductA()
        {
            return new ProductA2();
        }
        public override AbstractProductB CreateProductB()
        {
            return new ProductB2();
        }
    }

    // "AbstractProductA" 

    abstract class AbstractProductA
    {

    }

    // "AbstractProductB" 

    abstract class AbstractProductB
    {
        public abstract void Interact(AbstractProductA a);
    }

    // "ProductA1" 

    class ProductA1 : AbstractProductA
    {
    }

    // "ProductB1" 

    class ProductB1 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    // "ProductA2" 

    class ProductA2 : AbstractProductA
    {
    }

    // "ProductB2" 

    class ProductB2 : AbstractProductB
    {
        public override void Interact(AbstractProductA a)
        {
            Console.WriteLine(this.GetType().Name +
              " interacts with " + a.GetType().Name);
        }
    }

    // "Client" - the interaction environment of the products 

    class Client
    {
        private AbstractProductA AbstractProductA;
        private AbstractProductB AbstractProductB;

        // Constructor 
        public Client(AbstractFactory factory)
        {
            AbstractProductB = factory.CreateProductB();
            AbstractProductA = factory.CreateProductA();
        }

        public void Run()
        {
            AbstractProductB.Interact(AbstractProductA);
        }
    }
}

Implementación de ejemplo c#

using System;

namespace Patterns.Creational
{
    // MainApp test application 

    class ExampleAbstractFactory
    {
        public static void Main()
        {
            // Create and run the Africa animal world 
            ContinentFactory africa = new AfricaFactory();
            AnimalWorld world = new AnimalWorld(africa);
            world.RunFoodChain();

            // Create and run the America animal world 
            ContinentFactory america = new AmericaFactory();
            world = new AnimalWorld(america);
            world.RunFoodChain();

            // Wait for user input 
            Console.Read();
        }
    }

    // "AbstractFactory" 

    abstract class ContinentFactory
    {
        public abstract Herbivore CreateHerbivore();
        public abstract Carnivore CreateCarnivore();
    }

    // "ConcreteFactory1" 

    class AfricaFactory : ContinentFactory
    {
        public override Herbivore CreateHerbivore()
        {
            return new Wildebeest();
        }
        public override Carnivore CreateCarnivore()
        {
            return new Lion();
        }
    }

    // "ConcreteFactory2" 

    class AmericaFactory : ContinentFactory
    {
        public override Herbivore CreateHerbivore()
        {
            return new Bison();
        }
        public override Carnivore CreateCarnivore()
        {
            return new Wolf();
        }
    }

    // "AbstractProductA" 

    abstract class Herbivore
    {
    }

    // "AbstractProductB" 

    abstract class Carnivore
    {
        public abstract void Eat(Herbivore h);
    }

    // "ProductA1" 

    class Wildebeest : Herbivore
    {
    }

    // "ProductB1" 

    class Lion : Carnivore
    {
        public override void Eat(Herbivore h)
        {
            // Eat Wildebeest 
            Console.WriteLine(this.GetType().Name +
              " eats " + h.GetType().Name);
        }
    }

    // "ProductA2" 

    class Bison : Herbivore
    {
    }

    // "ProductB2" 

    class Wolf : Carnivore
    {
        public override void Eat(Herbivore h)
        {
            // Eat Bison 
            Console.WriteLine(this.GetType().Name +
              " eats " + h.GetType().Name);
        }
    }

    // "Client" 

    class AnimalWorld
    {
        private Herbivore herbivore;
        private Carnivore carnivore;

        // Constructor 
        public AnimalWorld(ContinentFactory factory)
        {
            carnivore = factory.CreateCarnivore();
            herbivore = factory.CreateHerbivore();
        }

        public void RunFoodChain()
        {
            carnivore.Eat(herbivore);
        }
    }
}

Arquitectura Ajax

Dar al usuario una buena experiencia en el uso de las aplicaciones web es uno de los puntos que permiten que este retorne a visitarlo. Todos hemos experiementado las aplicacionesweb  en las que para cargar un dato necesitamos esperar a que toda la página se cargue para obtene resultados, imaginarse recargar toda la página por un dato especifico no es realmente agradable, gracias AJAX podemos solventar esto.

Lo que Ajax utiliza JavaScript combinado con XML para racargar la información del servidor sin refrescar la página, lo que mejora la experiencia del usuario y el ancho de banda requerido para el paso de información disminuye

Podemos observar la diferencia entre el modelo clasico y un modelo con AJAX.

Dentro de los casos en los cuales es aconsejable la utilización de AJAX se tiene:

• Validación de información de formularios
• Autocompletar información(correos electrónicos, nombres, etc.)
• Operaciones en donde se maneja maestro detalle
• Barras de progreso, mapas, entre otros.

Existen varias alternativas para implentar AJAX, dentro de las que mas se recomienda son las librerias de cliente para Java Script, por el mayor control del lado del cliente, asi como navegadores, facilidad de desarrollo, etc.