LINQ hecho fácil

Acabo de encontrar una especie de notepad para escribir consultas LINQ. Se llama LINQpad y es una pequeña aplicación (2 megas) muy útil para empezar a crear consultas con esta herramienta de consulta tan potente.

Además viene cargada con un buen montón de ejemplos y minitutoriales, así como un asistente de conexión rápida a bases de datos SQL-Server (Como el incluído en Visual Studio, o en las versiones express) para poder hacer consultas sobre la Base de Datos casi sin pensar. También se incluyen ejemplos para hacer consultas sobre arrays de datos y demás.

Hale, a disfrutar el Linqpad!

Publicado en C#, Computacion. Etiquetas: , , . Leave a Comment »

Cronometrar el tiempo con .NET (C#)

En el post anterior sobre paralelismo se ha hecho uso de una técnica muy sencilla (y eficaz) para medir tiempos de ejecución para la plataforma .NET,

Una utilidad es por ejemplo, controlar el tiempo que se tarda en finalizar una tarea para poder identificar (a mano) cuellos de botella, programar un cronómetro, etc.

//Guarda la hora justo antes del proceso a cronometrar
DateTime tiempo1 = DateTime.Now;

/*
 * ... Algun cómputo por aquí ...
 */

//Guarda la hora al finalizar
DateTime tiempo2 = DateTime.Now;

//Crea un "intervalo temporal"
TimeSpan total = new TimeSpan(tiempo2.Ticks - tiempo1.Ticks);

//Ya puedes mostrar en pantalla o guardar en una cadena
// (o lo que sea) el tiempo transcurrido (con total precisión)
System.Console.WriteLine(total.ToString());

Ejemplo con Parallel.FX

Parallel.FX es una librería (actualmente en Community Technology Preview, o sea, que ni siquiera es beta) diseñada para facilitar el aprovechamiento de los procesadores multicore-manycore a los programadores.

La programación paralela realmente supone un cambio en la forma de pensar de los programadores, especialmente si hay que gestionar los hilos manualmente, por eso esta librería intenta facilitar enormemente esa tarea.

Por ello, y en primer lugar, tenemos que instalarnos el .NET framework 3.5 (el último que hay actualmente), que trae por defecto la instalación de Visual Studio 2008 (Descarga disponible por ELMS, cortesía del servicio de informática) y a continuación, hay que instalar la librería Parallel.FX desde el centro de descargas de Microsoft. Está en inglés, pero eso no es una sorpresa (Parallel.FX ni siquiera es beta, recordáis?)

Para este ejemplo, vamos a necesitar únicamente una aplicación Windows, en la que vamos a utilizar tan sólo dos botones y un richTextBox. De manera opcional se puede añadir un ProgressBar cuyo estilo sea “marquee” para comprobar cuándo y cómo se queda congelada la aplicación al ejecutar los bucles de prueba.

parallel.example (Visual Studio, C#)

Una vez tenemos la ventana con los botones y el richtextbox hay que agregar una referencia a System.Threading en el proyecto. El motivo para esto es que deseamos utilizar la versión de System.Threading que nos proporciona  Parallel.FX en vez de utilizar la que trae .NET 3.5. Sabremos que utilizamos la versión correcta porque en las propiedades de la referencia aparece la siguiente descripción: Parallel Extensions to the .NET Framework.

Una de las herramientas más útiles proporcionadas por Parallel.FX es el bucle Parallel.For, cuya sintaxis se muestra en el código incluído al artículo.

Una vez hecho todo eso (Instalar .NET 3.5, Instalar Parallel.FX, Crear nuevo proyecto win32, Añadir los botones y el richtextbox a la ventana, Agregar referencia a System.Threading) tan sólo queda reemplazar el código fuente predeterminado de la ventana por el siguiente:

//Ejemplo que usa Parallel.FX
using System;
using System.Windows.Forms;
using System.Threading;
//Aplicación paralela Ejemplo
namespace Parallel.Example
{
  public partial class Form1 : Form
  {
  public Form1()
  {
  InitializeComponent();
  }
  //Bucle normal
  private void button1_Click(object sender, EventArgs e)
  {
  DateTime t1 = DateTime.Now;
  //Hacer 20 veces
  for (int i = 0; i < 20; i++)   {   //Dormir 100 milisegundos   Thread.Sleep(100);   }   DateTime t2 = DateTime.Now;   //Calcular tiempo transcurrido   TimeSpan t = new TimeSpan(t2.Ticks - t1.Ticks);   this.richTextBox1.Text = t.ToString();   }   //Bucle con Parallel.FX   private void button2_Click(object sender, EventArgs e)   {   DateTime t1 = DateTime.Now;   //Hacer 20 veces   System.Threading.Parallel.For(0, 20, delegate(int i)   {   //Dormir 100 milisegundos   Thread.Sleep(100);   });   DateTime t2 = DateTime.Now;   //Calcular tiempo transcurrido   TimeSpan t = new TimeSpan(t2.Ticks - t1.Ticks);   this.richTextBox1.Text = t.ToString();   }   } } [/sourcecode] Como anticipo, indico que el primer bucle (el no paralelo) tardará alrededor de dos segundos en finalizar, mientras el bucle que usa el Parallel.For tardará alrededor de 1 segundo en un procesador dual core (o medio segundo en un quad core). Como curiosidad, veis que Parallel.For es en realidad una función con tres parámetros: Inicio, Fin y Función_a_Ejecutar (El delegate).

Salario medio de un programador

http://www.tufuncion.com/trabajo-programador/

No está tan mal (comparado con otros trabajos), pero aún hay mucho camino por recorrer, y más teniendo en cuenta las ingentes cantidades de dinero que la industria del software mueve…

Eso sí, lo que realmente da pena es el nivel de los salarios en general de los españoles: Tanto trabajo para tan poco dinero, y encima los precios por las nubes.

Incrustación de aplicaciones con System.AppDomain

Con C#, y gracias a System.AppDomain extender la funcionalidad de una aplicación mediante plugins es un juego de niños. Una forma un tanto bruta de hacerlo, es considerar que los plugins son programas externos que ejecutan una serie de acciones necesarias y pueden devolver un valor (en forma de archivo en disco). Un ejemplo de este tipo de plugins lo tenemos en la implementación de los plugins para el programa de edición gráfica GIMP (Gnu Image Manipulation Program), el cual se vale de multitud de pequeños plugins en forma de programas ejecutables que se utilizan para aplicar filtros o efectos a una imagen.

En este caso, vamos a hacer un programa muy sencillo que funcione como un servidor de aplicaciones, de forma que dos o más aplicaciones se puedan lanzar simultáneamente en diferentes hilos, lo que permite aprovechar los procesadores multicore ejecutando cada aplicación en cores distintos.

Forma de uso del código: Se crean dos proyectos de consola, se copia el código fuente del servidor en uno, y el del programa ejemplo en otro. Una vez creados se generan los dos, y se copian a la carpeta raíz ( C:\ ), y se ejecuta el programa servidor. Éste incrustará dos copias del programa ejemplo, que imprime cierto número de veces su identificador de ejecución único, y se podrá observar cómo los resultados impresos por cada programa se van intercalando gracias al paralelismo de usar hilos.

Servidor (programa que incrusta otros programas en hilos):

using System;
using System.Threading;
//using System.Reflection;
namespace remoteInvoker
{
  class Program
  {
    static void Main(string[] args)
    {
      //Mostrar el AppDomain predefinido.
      string callingDomainName = Thread.GetDomain().FriendlyName;
      Console.WriteLine(”AppDomain Servidor: “+callingDomainName);
      //Invoca al creador de aplicaciones
      crearAplicacion(@”c:\appdomainExperiment.exe”);
      crearAplicacion(@”c:\appdomainExperiment.exe”);
      //Fin
      Console.WriteLine(”Server: exit”);
      Console.ReadKey(true);
    }

    /// Crea un hilo que ejecuta una aplicación
    private static void crearAplicacion(string aplicacion) {
      Aplicacion app = new Aplicacion(aplicacion);
    }
  }

  /// Incrusta un ensamblado en un hilo para ejecutarlo
  class Aplicacion {
    // Nombre (url) de la aplicación
    string appName;

    /// Constructor, crea un dominio predeterminado
    public Aplicacion(string aplicacion) {
      appName = aplicacion;
      Thread appThread = new Thread(new ThreadStart(doWork));
      appThread.Start();
    }

    /// Método de ejecución del hilo
    private void doWork(){
      //Crea un dominio de ejecución para este hilo
      AppDomain dominio = AppDomain.CreateDomain(”serverDomain”);
      //Ejecuta el ensamblado
      dominio.ExecuteAssembly(appName);
      //Descarga el Dominio
      AppDomain.Unload(dominio);
    }
  }
}

Programa de Ejemplo:

using System;
using System.Threading;
namespace appdomainExperiment
{
  class Program
  {
  static void Main()
  {
  System.Console.BackgroundColor = ConsoleColor.Blue;
  Console.WriteLine(”Hola Mundo! (Método Principal)”);

//Obtiene el identificador único de ensamblado en ejecución
  Guid k = System.Guid.NewGuid();
  for (int i = 0; i < 10; i++)   {   Console.WriteLine(k.ToString());   Thread.Sleep(10);   }   try   { //Escribe el nombre de dominio de la aplicación   Console.WriteLine(”AppDomain Cliente: ” +   System.AppDomain.CurrentDomain.DomainManager.EntryAssembly.FullName);   }   catch   {   Console.WriteLine(”AppDomain Cliente: Aplicación independiente”);   }   System.Console.BackgroundColor = ConsoleColor.Black;   }   } } [/sourcecode]

Test de Turing? alguien podría superarlo

http://www.neoteo.com/tabid/54/ID/5530/Default.aspx

Existe un software en desarrollo, que requerirá la potencia del famoso Blue Gene de IBM, y que podría superar la prueba del test de Turing. Una Inteligencia Artificial con una base de conocimiento ingente, recuerdos de una época escolar, estados de ánimo, capaz de identificar los estados mentales de aquellos con quienes interactúa además de los suyos propios. En definitiva, una IA avanzada capaz de engañar a cualquier interlocutor, que sería incapaz de distinguir a la máquina de un ser humano real.

Se presentaría en forma de avatar con el que otros avatares (manejados por humanos) interaccionarían. Aunque tiene trampa: Puedes identificar a la IA porque… ¡sabe de todo, y sin errores!

Creacionismo vs. Evolucionismo?

http://www.el-nacional.com/www/site/detalle_noticia.php?q=nodo/15989

Desde luego, hay gente especial, pero especialmente peligrosos son los que pretenden inundar el mundo con ideas pseudocientíficas negando la teoría de la evolución.

Parece que les resulta imposible aceptar que no somos el centro del universo, o que la evolución es la herramienta de optimización más potente jamás descubierta (no creada, sino descubierta)

He aquí un hecho probado, por mucho que les pese… los textos bíblicos también fueron escritos por seres humanos, y su forma actual viene determinada por un largo proceso de evolución a lo largo de los siglos en el que se han seleccionado y adaptado los textos más apropiados para representar una serie de valores. Exactamente igual que la teoría de la evolución, aunque hay quien prefiere llamarla Ley de la Evolución, que a día de hoy sigue evolucionando y refinándose con cada nueva sorpresa que encuentran los científicos.

Esperemos que el pensamiento crítico no se extinga, y que no regresemos a una nueva edad oscura pseudomedieval.

Publicado en friki, Opinión. Etiquetas: , . 11 Comments »