Blog de Andres Urena

Esta idea tal vez ya paso por la cabeza de alguien mas, no es ninguna novedad, pero es bueno compartir este tipo de "componentes" que nos facilitan la vida al momento de encarar un proyecto.

En el caso especifico de este código, se ha creado una actividad que esta orientada a ser usada con Window Workflow Foundation para el envio de correos electronicos, si bien esta clase es basica, es muy util (asi lo veo yo) y el código puede llegar a crecer de acuerdo a las necesidades propias de su implementación.

Los namespaces necesarios para el proyecto son:

• System.Workflow.Activities
• System.Workflow.ComponentModel
• System.Workflow.Runtime

Sin mas preambulo aquí les dejo el código.

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Collections;
using System.Drawing;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Design;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Serialization;
using System.Workflow.Runtime;
using System.Workflow.Activities;
using System.Workflow.Activities.Rules;

namespace Workflows.Activities
{
    public partial class EnviarMail: System.Workflow.ComponentModel.CompositeActivity
   {
        public EnviarMail()
        {
            InitializeComponent();
        }

        [Description("El campo A(dirección destino) del correo electrónico")]
        [Category("AddressTo")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string AddressTo
        {
            get{ return(string)GetValue(AddressToProperty); }
            set{ SetValue(AddressToProperty, value); }
        }

        // DependencyProperty para AddressTo.
       public static readonly DependencyProperty AddressToProperty = DependencyProperty.Register("AddressTo", typeof(string), typeof(EnviarMail));

        [Description("El campo De(dirección origen) del correo electrónico")]
        [Category("AddressFrom")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string AddressFrom
        {
            get{ return(string)GetValue(AddressFromProperty); }
            set{ SetValue(AddressFromProperty, value); }
        }

        //DependencyProperty para AddressFrom
       public static readonly DependencyProperty AddressFromProperty = DependencyProperty.Register("AddressFrom", typeof(string), typeof(EnviarMail));


        [Description("El campo asunto del correo electrónico")]
        [Category("Subject")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string Subject
        {
            get{ return(string)GetValue(SubjectProperty); }
            set{ SetValue(SubjectProperty, value); }
        }

        //DependencyProperty para Subject.
       public static readonly DependencyProperty SubjectProperty = DependencyProperty.Register("Subject", typeof(string), typeof(EnviarMail));


        [Description("El Cuerpo del mensaje")]
        [Category("MailMessage")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string MailMessage
        {
            get{ return(string)GetValue(MailMessageProperty); }
            set{ SetValue(MailMessageProperty, value); }
        }

        //DependencyProperty para MailMessage.
       public static readonly DependencyProperty MailMessageProperty = DependencyProperty.Register("MailMessage", typeof(string), typeof(EnviarMail));


        [Description("Servidor para envio de correo electronico")]
        [Category("SmtpServer")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string SmtpServer
        {
            get{ return(string)GetValue(SmtpServerProperty); }
            set{ SetValue(SmtpServerProperty, value); }
        }

        //DependencyProperty para SmtpServer.
       public static readonly DependencyProperty SmtpServerProperty =
            DependencyProperty.Register("SmtpServer", typeof(string), typeof(EnviarMail));

        [Description("Puerto por el que se esta presente el servicio de smtp")]
        [Category("SmptPort")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public int SmtpPort
        {
            get{ return(int)GetValue(SmtpPortProperty); }
            set{ SetValue(SmtpPortProperty, value); }
        }

        //DependencyProperty para SmtpPort.
       public static readonly DependencyProperty SmtpPortProperty =
            DependencyProperty.Register("SmtpPort", typeof(int), typeof(EnviarMail));

        [Description("Nombre de usuario para acceder al servidor de SMTP")]
        [Category("Username")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string UserName
        {
            get{ return(string)GetValue(UserNameProperty); }
            set{ SetValue(UserNameProperty, value); }
        }

        //DependencyProperty para UserName.
       public static readonly DependencyProperty UserNameProperty =
            DependencyProperty.Register("UserName", typeof(string), typeof(EnviarMail));


        [Description("Password del usuario para el envio de correo electronico")]
        [Category("Password")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public string Password
        {
            get{ return(string)GetValue(PasswordProperty); }
            set{ SetValue(PasswordProperty, value); }
        }

        // DependencyProperty para Password.
       public static readonly DependencyProperty PasswordProperty =
            DependencyProperty.Register("Password", typeof(string), typeof(EnviarMail));


        [Description("Bandera que determina si se debera proveeder de credenciales para el envio de mails")]
        [Category("UseSSL")]
        [Browsable(true)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
        public bool UseSSL
        {
            get{ return(bool)GetValue(UseSSLProperty); }
            set{ SetValue(UseSSLProperty, value); }
        }

        //DependencyProperty para UseSSL.
       public static readonly DependencyProperty UseSSLProperty =
            DependencyProperty.Register("UseSSL", typeof(bool), typeof(EnviarMail));

        protected override ActivityExecutionStatus Execute(ActivityExecutionContextcontext)
        {
            try
           {
                System.Net.Mail.MailMessage mimail = newSystem.Net.Mail.MailMessage(AddressFrom, AddressTo, Subject, MailMessage);
                System.Net.Mail.SmtpClient mismtp = newSystem.Net.Mail.SmtpClient();
                mismtp.Host = SmtpServer;
                mismtp.Port = SmtpPort;
                mismtp.EnableSsl = UseSSL;
                if(UseSSL)
                { mismtp.Credentials = new System.Net.NetworkCredential(UserName,Password); }
               
                mismtp.Send(mimail);
                returnActivityExecutionStatus.Closed;
            }
            catch(System.Net.Mail.SmtpExceptionsmtpEx)
            {
                return HandleFault(context, smtpEx);
            }
        }
        protected override ActivityExecutionStatus HandleFault(ActivityExecutionContextexecutionContext, Exceptionexception)
        {
            return base.HandleFault(executionContext, exception);
        }

    }
}

Desde hace ya varias versiones, Visual Studio trae un tipo de proyecto que nos facilita las tareas de despliegue de soluciones, y ya en las últimas versiones ha venido ofreciendo una herramienta realmente confiable y de fácil implementación.

Los proyectos de Setup & Deployment se diferencian del resto por que no se debe escribir ni una sola línea de código para que funcionen, es mas si se utiliza el asistente para incrustar uno de estos proyecto en nuestra solución no necesitamos mas para obtener como resultado un instalador (básico) para un despliegue indoloro (depende del grado de complicación al que hayamos llegado).

Como soy un WebDeveloper el presente post trata (como lo dice el título) sobre instaladores para sitios web, si bien un sitio web no se lo instala en todas partes como una aplicación de escritorio o mobile, en el caso de trabajar con clientes externos a nuestro entorno es necesario (lo dicen las buenas prácticas) presentar un producto bien terminado, empaquetado y listo para la distribución. Comencemos entonces.

Voy a suponer que ya contamos con una solución web lista y funcionando, vamos a agregar un proyecto mas de tipo setup & deployment y como veran tenemos varias opciones, para hacer el post mas didáctico vamos a ir por el Setup Wizard, este proyecto nos tomara como proyecto principal a aquel proyecto que tengamos como start up de la solución, en el caso de proyectos web solo podemos incluir el Content de este, aquí vienen todos los assemblies que neesita para funciona asi que no es necesario incluir el resto de proyectos (librerías) al instalador.

Una vez ubicado el proyecto en el directorio correspondiente llegamos a la vista del file system del instalador, veamos sus partes.

En lugar de tener un espacio de edición de código, tenemos una especie de explorador, a la izquierda se ven las carpetas o folders que serán desplegados en la máquina destino (target) y a la derecha la lista de archivos, assemblies, project outputs y demas recursos que necesite el instalador para cumplir su misión, para poder agregar algo al file system solo necesitamos hacer click con el boton derecho sobre la zona de archivos y seleccionar la opción que se adecue a nuestras necesidades. (entre los recursos que normalmente se adjuntan estan los documentos de licencias, imagenes de splash, banners y assemblies que no van dentro de la solución pero que son necesarias).

Contando solo con esto ya tenemos un instalador de nuestro proyecto, pero, como todos sabemos una web que no se conecte a una base de datos no es web (punto de vista personal) entonces lo que faltaría aquí es establecer la conexión a la base de datos. ¿Y qué pasa si la base de datos no existe? bueno hay que crearla, desde la instalación el usuario final debería ser capaz de realizar todas estas tareas (y muchas otras más) sin complicarse la vida, es mas un usuario final con 0(cero) conocimiento de desarrollo de software debería ser capaz de instalar nuestro producto así como instala un juego o una aplicación de escritorio.

Obviamente una aplicación web no se parece mucho a una de escritorio, depende de la existencia de IIS y de los permisos necesarios para acceder a este. Es bueno saber que un setup de Windows Installer es capaz de detectar aquellos recursos que sean necesarios para el producto que se esta instalando, en este caso IIS, si este servicio no esta presente el instalador se encarga de levantar una excepción informandole al usuario final la situación.

Volviendo al Demo, necesitamos crear la base de datos a la que nuestra web se conectara y ademas tenemos que modificar el archivo web.config para indicar que la cadena de conexión apunta al servidor del cliente con el usuario que este ha definido. Para lograr esto hay que escribir código. :)

Existe una clase que permite que sobrecarguemos los procesos que se llevan a cabo cuando una aplicación (en este caso web) se está instalando, esta es la clase installer (System.Configuration.Install.Installer)

Como aprovechar la clase Installer

La idea de esta clase es la de proporcionar un vínculo entre el proceso de instalación y los eventos que esta genera con las modificaciones y/o configuraciones que necesita nuestra solución para estar correctamente instalada, esta clase está disponible sin importar el tipo de proyecto que se este trabajando (web o escritorio) pero para el caso del demo vamos a trabajar con Web.

Para comenzar, la clase Installer debe ser heredada, y esta clase derivada deberá encontrarse en un componente que este incluido en el proyecto de instalacion, las cosas deberán verse de esta forma:

Como veran el proyecto CustomInstaller solo tiene una clase (CustomInstaller.cs) que es derivada de la clase Installer, este proyecto es de tipo ClassLibrary y el output del mismo debera estar incluido en el proyecto de instalación.

El namespace System.Configuration.Install debe estar referenciado en el proyecto CustomInstaller para poder tener dicponible la clase Installer.

Existen procesos que pueden ser sobrecargados al heredar esta clase, Install, Commit, Rollback y Unistall, para cada uno de ellos podemos escribir el código que necesitemos, en el caso de este demo solo vamos a usar el proceso Install. El código debería verse mas o menos asi:

using System;
using System.Configuration;
using System.Configuration.Install;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Web.Configuration;
using System.DirectoryServices;
using System.Data;
using System.Data.SqlClient;
using System.Text;

namespace CustomInstaller
{
    [RunInstaller(true)]
    public class CustomInstaller : Installer
    {
        const string DATABASE_CONNECTION_KEY = "ConnectionStringDemo";
        public override void Commit(System.Collections.IDictionary savedState)
        {
            base.Commit(savedState);
        }
        public override void Install(System.Collections.IDictionary stateSaver)
        {
            base.Install(stateSaver);
            string targetSite = string.Empty;
            string targetVDir = string.Empty;
            string targetDirectory = string.Empty;
            string Server = string.Empty;
            string Database = string.Empty;
            string Username = string.Empty;
            string Password = string.Empty;

            try
            {
                //obtiene la informacion pasada por el usuario
                targetSite = Context.Parameters["targetsite"];
                targetVDir = Context.Parameters["targetvdir"];
                targetDirectory = Context.Parameters["targetdir"];
                //'Conexion a DB
                Server = Context.Parameters["Server"];
                Database = Context.Parameters["Catalogo"];
                Username = Context.Parameters["Username"];
                Password = Context.Parameters["Password"];
            }
            catch(Exception ex)
            {
                throw new Exception("Error al acceder a los valores de contexto :: " , ex);
            }
            InstallDatabase(targetSite, targetVDir, Server, Database, Username, Password);
        }
        public override void Rollback(System.Collections.IDictionary savedState)
        {
            base.Rollback(savedState);
        }
        public override void Uninstall(System.Collections.IDictionary savedState)
        {
            base.Uninstall(savedState);
        }
        private void InstallDatabase(string targetSite, string targetVDir, string server, string database, string Username, string Password)
        {
            string con = string.Empty;
            SqlCommand cmd = new SqlCommand();
            try
            {
                //Creando la base de datos con el nombre proporcionado por el usuario
                con = string.Format("server={0};database=master;UID={1};PWD={2}", server, Username, Password);
                cmd.CommandText = string.Format("create database {0}",database);
                cmd.CommandType = CommandType.Text;
                cmd.Connection = new SqlConnection(con);
                cmd.Connection.Open();
                cmd.ExecuteNonQuery();
                cmd.Connection.Close();
            }
            catch (Exception ex)
            {
                throw new Exception(string.Format("La base de datos {0} no pudo ser creada ",database), ex);
            }
            try
            {
                //Creando la base de datos (contenido)
                con = string.Format("server={0};database={3};UID={1};PWD={2}", server, Username, Password, database);
                StreamReader script = new StreamReader(@"C:\inetpub\wwwroot\" + targetVDir + @"\DatabaseScript.sql");
                cmd.CommandText = script.ReadToEnd();
                cmd.CommandType = CommandType.Text;
                cmd.Connection = new SqlConnection(con);
                cmd.Connection.Open();
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                throw new Exception("Los datos de la base de datos no fueron creados :: " , ex);
            }
            finally
            {
                if (cmd.Connection.State == ConnectionState.Open)
                { cmd.Connection.Close(); }
            }

            try
            {
                //Abriendo el archivo web.config del sitio web
                Configuration config = WebConfigurationManager.OpenWebConfiguration("/" + targetVDir);

                //Creando una nueva llave en la seccion de connectionStrings para nuestra base de datos
                ConnectionStringSettings appDatabase = new ConnectionStringSettings();
                appDatabase.Name = DATABASE_CONNECTION_KEY;
                appDatabase.ConnectionString = con;
                appDatabase.ProviderName = "System.Data.SqlClient";

                config.ConnectionStrings.ConnectionStrings.Clear();
                config.ConnectionStrings.ConnectionStrings.Add(appDatabase);

                //grabando las modificaciones
                config.Save();
            }
            catch (Exception ex)
            {
                throw new Exception("El archivo web.config no pudo ser modificado :: " , ex);                
            }
        }
    }
}

Nota

El atributo [RunInstaller(true)] debe estar presente, de lo contrario la clase no se instancia y por ende el código no se ejecuta.

Interfaz de usuario del asistente

Como se puede ver, no es nada complejo, ahora lo que necesitamos es pasarle los parametros de contexto desde la interfaz (UI) del asistente de instalación, para eso vamos a adicionar pasos al instalador.

Primero vamos a familiarizarnos con el IDE y como agregamos estos pasos al asistente, para ver el UI del mismo tenemos 2 opciones, hacer click con el boton derecho sobre el proyecto de instalación en la opción ver (view), seleccionar Interfaz de usuario (User Interface)

Otra opción es usando los botones en la ventana del explorador de la solución al seleccionar el proyecto de instalación. (el tercero de derecha a izquierda)

La IDE que se desplegará debiera verse mas o menos asi:

En la imagen se puede ver que ya tengo agregado un paso con el nombre Texboxes (A) y que en la ventana de propiedades se ven todas las propiedades que se tienen disponibles. Como verán (o mejor dicho como no verán) no hay forma de ver la interfaz de forma gráfica como un formulario windows, debemos trabajar todo a traves de estas propiedades; todas las propiedades que terminen con "label" son las etiquetas que mostraran una descripción del campo que se solicita al usuario, las que terminan con el termino "property" son el nombre con el que seran administradas las propiedades desde la clase Installer (Context) (eso se puede ver en el código de la clase derivada de Installer)

El nombre de las propiedades sera siempre en mayúsculas (automaticamente) y debe ser exactamente el mismo cuando accedamos a ellas desde la información de contexto.

Deben preguntarse ¿Por qué hay dos grupos, Install y Administrative Install? (bueno si no se lo preguntaban antes ahora sí) la razón es sencilla, el grupo Install es el que se despliega al usar el instalador como usuario final, es decir, que el usuario inicie el proceso de instalacion al ejecutar el setup.exe, el otro grupo (Administrative Install) se ejecuta cuando un administrador de red ejecuta el instalador desde un distribuidor de aplicaciones (SMS, MOS, etc.) el demo no va a tocar ese tema (aun) asi que lo dejamos como se ve e la imagen.

En este caso solo he agregado 1 paso más al instalador, se pueden agregar cuantos pasos sean necesarios para obtener toda la información requerida por el instalador para que todo salga bien, en el caso de este demo solo se solicita la información necesaria para la creación de la base de datos a la que nuestra aplicación web se va a conectar (servidor, base de datos, usuario y clave).

Con todos estos pasos (que no son muchos) es posible crear un instalador que permitirá no solo instalar sino que reparar y desinstalar nuestra aplicación en el cliente sin complicarle la vida.

Después de tantas acaloradas discuciones con personas de diferentes grupos y profesiones tengo ahora el agrado de decirles que yo tengo la razón!!!

Esta declaración viene a consecuencia de una nota la cual respalda los constantes errores de los que yo fuí partícipe en la empresa donde trabajaba antes (por razones mas que evidentes no puedo decir el nombre, pero aquellos que me conocen saben de quien hablo), constantes perdidas de datos, corrupción de versiones y etiquetas de VSS, pantallas azules al menos 1 por día en alguna PC y un sin fin de errores que no solo interrumpian el trabajo sino que lo volvian frustrante.

En una oportunidad tuve la "suerte" de trabajar en la localización de un demo para dicha empresa, este demo tenía errores muy particulares, cansado de esa situación (y hechandole la culpa a la PC) cambie de máquina y me puse a trabajar en mi notebook donde tengo todo el software licenciado (gracias a un buen amigo que me regalo el msdn universal) y grande fue mi sorpresa cuando el demo comenzo a funcionar perfectamente sin realizar ninguna modificación.

¿Cosa de Mandinga? Tal vez, pero de algo estoy seguro, desarrolladores capaces de crear un SO que es utilizado por gran parte de los usuarios de PC del mundo son capaces de PROTEGER su trabajo y sus productos con backdoors como estos.

Si bien a muchos esto perjudica, hay que considerar que al usar un software pirata se perjudica al creador de ese software.

Si, ya se, "Las empresas de software son moustros llenos de dinero y poder asi que no les afecta"

Y la pregunta del millon es, ¿Y que pasa si el software que hacemos nosotros llega a ser pirateado y usado de forma masiva?

Las leyes se cumplen, no se negocian.

Nota completa

Entiendase por almacenamiento aislado a la porsión de información (que puede servir como datos de configuración por ejemplo) que podemos almacenar de forma segura en la máquina del cliente (solo para aplicaciones de escritorio), en el ejemplo de código a continuación veran que solo almaceno un string, es demostrativo, se podría guardar tanta información como sea necesaria.

Imports System.IO.IsolatedStorage
Imports System.IO

    ''' <summary>
    ''' Permite inicializar un archivo de almacenamiento aislado
    ''' para la aplicacion
    ''' </summary>
    ''' <remarks>si el archivo de almacenamiento ya existe sera 
    ''' actualizado con la nueva información</remarks>
    Private Sub SetIsolated()
        Dim isoFile As IsolatedStorageFile = IsolatedStorageFile.GetMachineStoreForAssembly()
        Dim isoStream As IsolatedStorageFileStream = New IsolatedStorageFileStream("sistem.dat", FileMode.OpenOrCreate, isoFile)
        Dim writer As New StreamWriter(isoStream)
        writer.WriteLine("esta es la configuracion almacenada")
        writer.Close()
    End Sub
    ''' <summary>
    ''' Permite obtener la información almacenada para este assembly de forma aislada
    ''' </summary>
    ''' <remarks>para poder leer el archivo debemos estar seguros que ya existe</remarks>
    Private Sub GetIsolated()
        Dim isoFile As IsolatedStorageFile = IsolatedStorageFile.GetMachineStoreForAssembly()
        Dim isoStream As IsolatedStorageFileStream = New IsolatedStorageFileStream("sistem.dat", FileMode.Open, isoFile)
        Dim result As String = New StreamReader(isoStream).ReadToEnd()
        Console.Write(result)
    End Sub


sub main()
        'almacenamiento aislado
        SetIsolated()
        GetIsolated()
    console.read()
end sub

Este post es para mostrar algo de código, como se puede usar el namespace de cryptography para encriptar un mensaje y volverlo a su estado original.

Para este ejemplo he usado DES(Data encription Standard) que es uno de los mas básicos, pero asi como implemente este se puede cambiar a cualquiera de los métodos simetricos de encriptación que vienen con .Net

Para ver mas informacion sobre Criptografia en .Net ver:System.Security.Cryptography

El código es el siguiente:

    Imports System.Security.Cryptography
    Imports System.IO
    ''' <summary>
    ''' permite encriptar un mensaje haciendo uso de uno de los servicios de encriptacion mas básicos
    ''' </summary>
    ''' <param name="message">Mensaje a encriptar</param>
    ''' <param name="key">Llave de encriptacion</param>
    ''' <param name="iv">Vector de inicializacion</param>
    ''' <returns>Coleecion de bytes que representan el mensaje encriptado</returns>
    ''' <remarks>Si bien este código hace uso del metodo DES sobrecargar este con los 
    ''' demas metodos simetricos no implica mayor complejidad</remarks>
    Private Function Encrypt(ByVal message() As Byte, ByVal key() As Byte, ByVal iv() As Byte) As Byte()
        Dim des As DES = New DESCryptoServiceProvider
        Dim crypto As ICryptoTransform = des.CreateEncryptor(key, iv)
        Dim cipherstream As New MemoryStream()
        Dim cryptostream As New CryptoStream(cipherstream, crypto, CryptoStreamMode.Write)
        cryptostream.Write(message, 0, message.Length)
        cryptostream.Close()
        Return cipherstream.ToArray()

    End Function
    ''' <summary>
    ''' permite desencriptar un mensaje haciendo uso de uno de los servicios de encriptacion mas básicos
    ''' </summary>
    ''' <param name="cypherText">Mensaje Encriptado</param>
    ''' <param name="iv">Vector de inicializacion</param>
    ''' <param name="key">Llave de encriptacion</param>
    ''' <remarks></remarks>
    Private Function Decrypt(ByVal cypherText() As Byte, ByVal iv() As Byte, ByVal key() As Byte) As String
        Dim des As DES = New DESCryptoServiceProvider()
        Dim crypto As ICryptoTransform = des.CreateDecryptor(key, iv)
        Dim cipherStream As New MemoryStream(cypherText)
        Dim cryptostrm As New CryptoStream(cipherStream, crypto, CryptoStreamMode.Read)
        Dim message As String
        message = New StreamReader(cryptostrm).ReadToEnd()
        Return message
    End Function

sub main()
    'Usando los métodos creados con un archivo de texto 
    Dim result() As Byte
    Dim algo As New FileStream("prueba.txt", FileMode.Open)
    Dim mifile(algo.Length) As Byte
    Dim mikey() As Byte = BitConverter.GetBytes(123465789123456789)
    Dim miiv() As Byte = BitConverter.GetBytes(987654321987654321)
    algo.Read(mifile, 0, algo.Length)
    result = Encrypt(mifile, mikey, miiv)
    Console.WriteLine("en encrypto")
    Console.WriteLine(BitConverter.ToString(result))
    Console.Read()
    Console.WriteLine(Decrypt(result, miiv, mikey))
    Console.Read()
end sub

Registrarse

viernes, 12 de septiembre de 2008 04:30 a.m. - viernes, 12 de septiembre de 2008 11:00 p.m. Buenos Aires

Colegio Universitario IES Siglo 21

Buenos Aires 563
Córdoba Argentina

Idiomas:
Español.

Productos:
Microsoft .NET.

Audiencia(s):
Education y Estudiante.

Información general del Evento

Cronograma Cells on Camp [Cert. Asist]

Cronograma Cells on Camp en Córdoba el día 12/09/2008

16:30 – 17:00 Registro de asistentes.

17:00 - 17:30 Tema: Bienvenida.

Introducción sobre el Programa Académico Microsoft, Células.Net y breve explicación sobre el programa del día.

Disertante: Pablo Listingart – Gerente de Desarrollo Academico y de Industria Microsoft Argentina

17:30 – 18:20 Tema: Silverlight 2.0

Veremos cómo escribir aplicaciones ricas que trabajen en distintos browsers y plataformas sin necesidad de escribir código Javascript, interactuando con lenguajes servidor de manera rápida.

Disertante: Ing. Matías S. Iacono.

Referencias: Matías Iacono ha trabajado con tecnologías Microsoft durante más de 13 años, enfocado en el desarrollo y gestión de software, tanto en aplicaciones de escritorio, como para dispositivos móviles y Web. Es Microsoft MVP en ASP y ASP.Net desde el año 2004 hasta la actualidad. Reconocido como orador regional INETA Latinoamérica. Ha trabajado para diversas empresas extranjeras y escrito y publicado artículos técnicos para revistas informáticas argentinas, noruegas, entre otras. En la actualidad se desempeña como ingeniero de software para Motorola Argentina, y como profesor en la Universidad Técnica Nacional

18:20 – 18:30 Break.

18:30 – 19:20 Tema: Microsoft AJAX. Conoceremos AJAX viajando a travéz de ejemplos prácticos desde un simple UpdatePanel hasta AJAX-Enabled WebServices y Patrones de Carga Incremental.

Disertante: Ing. Juan Pablo Ibañez

Referencias: Juan Pablo Ibañez (MCP) es Ingeniero de Sistemas enfocado en el desarrollo de soluciones de software. Apasionado por los desarrollos web haciendo uso de las últimas tecnologías Microsoft. Ha trabajado para empresas tanto nacionales como internacionales.
Publica asiduamente artículos sobre tecnología para distintas revistas técnicas.
Es profesor en la Universidad Tecnológica de Córdoba.

19:20 – 20:20 Tema: Micro Framework: Se desarrollará la vista general de la tecnología, alternativas de mercado para el tratamiento de escenarios micro móviles, arquitectura de la tecnología y demostraciones generales con placa de desarrollo piloto. Además se mostrarán ejes de proyectos cursados con esta tecnología.

Disertante: Ing. Nicolás Bortolotti.

20:20 – 20:30 Break.

20:30 – 21:10 Tema: Microsoft Robotics Studio.

Disertante: Damian Galletini

Referencias: Microsoft Certified Application Developer, Windows Vista Launcher y Student Partner de la empresa de Redmond. Actualmente Damián trabaja como Ingeniero de Desarrollo en Raona, donde participa en la construcción de la siguiente generación de aplicaciones para Windows Vista.

Damián participa activamente en la comunidad de desarrolladores a través de distintos foros, es orador habitual en eventos técnicos en Córdoba y contribuye apasionadamente a la difusión de conocimientos en el entorno académico.

21:10 – 22:00 Tema: Microsoft XNA Game Studio.

Explicación breve del funcionamiento del XNA Framework. Tutorial “Crea tu propio juego en 30 minutos”.

Disertantes: Célula Académica “The GameMakers”.

Referencias: Célula compuesta por: Dorsch, Erica; Ferrer José; Ivanissevich, Miguel; Laborde Miguel; Rosso Agustín. Todos estudiantes, cursando segundo año de la carrera Tecnicatura Superior en Programación.

22:00 – 22:40 Tema: Web Services y AJAX.

Architecture Oriented Service. Formas de utilización. Ejemplos prácticos.

Disertantes: Células Académicas “Hibridos” y “Developnet”.

Referencias: Célula “Hibridos” compuesta por: Díaz, Juan Emmanuel; Jalid, Leonardo; Marquinez, Javier. Todos estudiantes cursando segundo año de la carrera Tecnicatura Superior en Programación.

Célula “Developnet” compuesta por: Gmelin, Rafael; Guzmán, Fernando; Morra, Ricardo Nicolás. Todos estudiantes cursando segundo año de la carrera Tecnicatura Superior en Programación.

22:40 Cierre. Sorteos.

Como ya se había tratado de establecer en un post anterior la forma de trabajar con Ingenieros de sistemas (y ramas anexas) para poder realizar un proyecto en grupo, debe obedecer a ciertos lineamientos que todo ser humano debe seguir para tener exito en todos los proyectos que emprende (si, se a determinado científicamente que el Ing. de sistemas es un ser humano :D)

Grupos grandes.

Entendamos como grupo grande a un conglomerado de personas que manteniendo su individualidad pretenden afrontar un reto en el que todos deben dirigirse a un mismo punto desde diferentes caminos. aunque este enunciado suene algo rimbombante, es eso lo que se pretende cuando se trabaja en grupo.

Tomemos el punto de vista de la teoría de sistemas; cada sistema puede estar en el marco de un sistema mas grande, es esta relación simbiótica la que permite que un macro sistema compuesto de muchos subsistemas pueda realizar una tarea específica por ejemplo el cuerpo humano. Imaginen que uno de los pulmones no esta de acuerdo con el funcionamiento de el corazón, o que un riñón decide dejar de funcionar sin ninguna razón aparente, ésto causa problemas no solo a esos organos sino a todo el cuerpo ocasionando un sinfin de síntomas que evitan que el resto del cuerpo funcione como deba. se podría decir que esto es una enfermedad.

Asi como las enfermedades el hecho que uno o varios de los integrantes de un equipo de trabajo no se sienta bien ya sea con el trabajo que realiza, con su grupo de compañeros, con el entorno en el que trabaja o algun otro elemento de su mundo laboral, causa que el equipo entero comience a experimentar los síntomas de una enfermedad comunmente llamada "empleado descontento".

Sintomas claros de esta "enfermedad" son:

Trabajo mediocre.-

Podría calificarse de trabajo mediocre al resultado de:

• La falta de comunicacion de abajo hacia arriba
• El empleo de mas horas de lo planificado para una tarea de baja complejidad
• El rehusarse a la utilización de las herramientas de control del proceso de trabajo (conciente o inconcientemente)
• La pérdida de tiempo en actividades no propias del trabajo en horario laboral
• Descontento con cualquier cambio en el entorno laboral

Las sutilizas del comportamiento humano deben ser bien identificadas, y es en este campo donde se deben realizar reuniones unipersonales con el equipo para recibir un "feedback" de la situación de "la persona" que esta detras del empleado, es muy factible que las inconformidades que ese empleado tenga sean muy fáciles de satisacer o de negociar, las negociaciones deberán encararse de forma Ganar - Ganar, es decir que ni la empresa ni el empleado deben sentir que despues de una negociación han perdido algo.

Si, como lo debes estar pensando, estas trabajando con un grupo grande de gente el hecho de reunirse con cada uno de ellos sería un problema logístico de proporciones bíblicas(bueno no tanto) entonces ¿que se debiera hacer?

DIVIDE Y VENCERAS

Hay formas(muy prácticas) de poder dividir al personal que esta asignado a un grupo de trabajo de tal forma que la comunicación ya sea de abajo hacia arriba o vice versa sea fluida y sin distorciones; una sola persona no es capaz de tener toda la visibilidad en detalle de la gestión de un proyecto y de recursos humanos.

Una de estas técnicas es la de dividir los grupos de trabajo, demasiado sencilla, pero, es muy efectiva, de esta forma podemos afrontar el reto de tener una idea muy clara de que pasa con el equipo de trabajo desde diferentes ópticas. Ahora, hay que saber que preguntar y como preguntarlo.

Muchas veces nos vamos a encontrar con desarrolladores y analístas que son muy sueltos y relajados al momento de hablar, con estas personas es muy poco probable que tengamos problemas al momento de la entrevista de feedback(llamemoslo asi por ahora); donde es posible que encontremos algo de dificultad en la comunicación es en esas personas que por alguna razón se sienten intimidados ya sea con el jefe o con el líder de proyectos. Es aquí donde el equipo de recursos humanos entra en acción y se encarga de las entrevistas, lo ideal sería comenzar por los mas juniors hacia arriba.

Esta temporada de entrevistas debiera tomar como máximo un par de semanas... sí solo un par y esto debido a que si se emplea demasiado tiempo en esta etapa la muestra recogida puede no estar del todo real, ya que la coyuntura se ha distendido y muchas situaciones pueden darse (ya se positivas o negativas) que afecten la información.

"... Como mantener a sus recursos rentables..."

La frase que acaban de leer es uno de los temas a tratar en una convención de dueños de empresas de diferentes rubros. Si bien el término rentable esta ampliamente aceptado, no es el correcto (o por lo menos para los recursos que son rentables).

En algún punto las empresas dejaron de contratar personas y empezaron a incrementar su bienes inmuebles? la respuesta a esa pregunta es un categórico NO, una de las cosas que podrian hacer para "mantener a sus tan apreciados recursos rentables" es dejar de considerarlos un mueble o un equipo que se conecta a la empresa de 9-5 (o el horario que sea) y empezar a tratarlos como personas.

SI SEÑORES los empleados son personas (aunque hay varios que clasificaron con la mínima nota), muchas veces el empleado migra a otra empresa en busca no solo de un sueldo mas alto, sino de un trato mas digno o de mejores oportunidades de crecimiento.

Quiero terminar con ese ultimo parrafo ya que este tema da para mas

(Continuará)