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.

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

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.

]]> http://faustol.wordpress.com/2007/12/12/arquitectura-ajax/feed/ 0 faustol image http://faustol.wordpress.com/2007/11/30/patrones-de-diseo/ http://faustol.wordpress.com/2007/11/30/patrones-de-diseo/#comments Fri, 30 Nov 2007 21:54:11 +0000 faustol http://faustol.wordpress.com/2007/11/30/patrones-de-diseo/ ]]>

Desarrollar software aparentemente es escribir unas líneas de código y hacer que funcione, realmente el proceso de desarrollo es complicado y los patrones de diseño nos ayudan a poder realizar dicha tarea de mejor forma.

Un patron de diseño segun Christopher Alexander

“describe un problema que ocurre una y otra vez en nuestro entorno, asi como la solución a ese problema, de tal modo que se pueda aplicar esta solución un millón de veces, sin hacer lo mismo dos veces”

Un patron contiene 4 elementos fundamentales:

• Nombre del patron
• Problema
• Solución
• Consecuencias

Los objetivos de los patrones son:

• Proporcionar catálogos de elementos reusables en el diseño de sistemas software.
• Evitar la reiteración en la búsqueda de soluciones a problemas ya conocidos y solucionados anteriormente.
• Formalizar un vocabulario común entre diseñadores.
• Estandarizar el modo en que se realiza el diseño.
• Facilitar el aprendizaje de las nuevas generaciones de diseñadores condensando conocimiento ya existente.

Estructura o plantilla de los patrones:

• Nombre del patrón: nombre estándar del patrón por el cual será reconocido en la comunidad (normalmente se expresan en inglés).
• Clasificación del patrón: creacional, estructural o de comportamiento.
• Intención: ¿Qué problema resuelve el patrón?
• También conocido como: Otros nombres de uso común para el patrón.
• Motivación: Escenario de ejemplo para la aplicación del patrón.
• Aplicabilidad: Criterios de aplicabilidad del patrón.
• Estructura: Diagramas de clases oportunos para describir las clases que intervienen en el patrón.
• Participantes: Enumeración y descripción de las entidades abstractas (y sus roles) que participan en el patrón.
• Colaboraciones: Explicación de las interrelaciones que se dan entre los participantes.
• Consecuencias: Consecuencias positivas y negativas en el diseño derivadas de la aplicación del patrón.
• Implementación: Técnicas o comentarios oportunos de cara a la implementación del patrón.
• Código de ejemplo: Código fuente ejemplo de implementación del patrón.
• Usos conocidos: Ejemplos de sistemas reales que usan el patrón.
• Patrones relacionados: Referencias cruzadas con otros patrones.

Estaré documentando mas sobre el tema.

Adjunto Material de Lectura, clase1, clase2

Arquitectura de Aplicaciones en Internet

Introducción a la POO

Construcción de Aplicaciones en capas