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.

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.

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.

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:

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

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

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.

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);
        }
    }
}

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.

]]> http://faustol.wordpress.com/2007/12/12/arquitectura-ajax/feed/ 0 faustol image