bloc-blog de .NET de www.d-activo.com

C#, el proyecto y el equipo humano

dactivo — Wed, 25 Jul 2007 10:14:00 GMT

DIFICULTAD: 1.
Uno se pregunta cómo se puede dar un salto cualitativo tan importante en lenguajes de programación en una empresa de software, quien haya pasado de programar asp o vb 6 a C# (y en su extension más amplia, .NET) comprenderá qué quiero decir.

Ya no hablo del éxito, sino de la calidad, el éxito se podría entender por estrategias de marketing, como por ejemplo, que Microsoft está adaptando algunas estrategias de las comunidades de código libre (codeplex.com, creación de blogs de programadores de Microsoft a mansalva etc...), o simplemente que MS triunfará siempre porque tiene el OS más extendido del planeta. Desde luego, el éxito influye porque se invierte más dinero en el producto y esto se supone que repercute en su calidad, aunque la ecuación capital-calidad no siempre tiene lugar.

También pienso que el software a la fuerza tiene que ir a más y mejor y que la calidad aumenta si aumenta la competitividad, y en ese sentido la lucha Sun MicroSystems-Microsoft ha sido sin duda importante al menos para incitar a una inversión en busca de un lenguaje que contrarrestara la influencia de Java.

No obstante, uno de los motivos más importantes es el personal que ha participado en este gran proyecto. Por un lado, programadores y arquitectos que emanan de diferentes universidades y empresas como puede ser (aunque más en .NET en general) Scott Guthrie, director general de la división de desarrollo de Microsoft, por mencionar uno.

Por otro lado, ha habido una parte clave de su personal procedente de Borland *,, empresa que hacía sombra en IDES (C++Builder, JBuilder) a cualquier adversario y expertos en compiladores modernos (TurboPascal, TurboBasic, Turbo C), de hecho los nuevos reclutados ex-Borland han ido trayendo de Scotts Valley(California) a Redmond a antiguos compañeros, así lo cuenta Charlie Calvert, ex-Borlander y conocido escritor de libros de programación (sobre todo de Delphi) y actual Community Program Manager de C# en una entrevista reciente, a base de ofertas irrechazables que en 2 casos sobrepasaron el millón de dólares (3 M$, Hejlsberg).

Uno de los ex-Borlandianos más destacados es el creador de Turbo Pascal y de Delphi (1995), que después de dirigir la creación de J++, es el arquitecto principal de C# y al que podemos considerar como el creador de C# y que incluso es el máximo promotor de LINQ que desembarcará con Visual Studio 2008 (ahora con codename Orcas):

http//es.wikipedia.org/wiki/Anders_Hejlsberg

Otras figura destacada, aunque de menor calibre, ha sido Chuck Jazdzewski, sucesor de Anders en Borland tras su ida aunque también voló a MS (aquí hay unos consejos para nuevos programadores de su parte), así como Blake Stone (arquitecto de JBuilder), Steve Teixeira (actual Group Program Manager for the Microsoft Visual C++ team)...

Si googleáis un ratito, veréis que la fuga de cerebros llevó a que Borland demandara a Microsoft allá por el 97 acusándoles de brain drain, All's fair in love and war?:

http://news.com.com/2100-1023-279561.html

No obstante, en el 99 se resolvió de un modo confidencial y amistoso, se dice que Microsoft y Borland empezaron a ser socios cuando compró 25 millones en acciones de Borland. Hoy día parece que tienen una buena relación y Borland ha creado Delphi para .NET.

CONCLUSIÓN

Esto hace que C# tenga un futuro prometedor porque la calidad de un lenguaje o de un proyecto en general procede del "capital humano" y de la interacción del capital humano (cómo el grupo de programadores se enriquece mutuamente y trabaja proactivamente), de las sienes y no de las líneas de código ni de la cantidad de microchips. Creo que un buen ejemplo de esto es el caso de C#.

*NOTAS Quien no conozca Borland, debe saber que se fundó en 1983 y que se puede considerar el inventor de los IDE de programación (entorno integrado de desarrollo,Integrated Development Environment):
http://es.wikipedia.org/wiki/Borland
http://www.cbronline.com/article_cbr.asp...

LECTURAS RECOMENDADAS

Un buen artículo de Enrique Dans donde intenta revalorizar la figura del programador:

"...(a la profesión de programador)La ha rodeado de una leyenda negra, casi de un escaso prestigio social, cuando en realidad, hablamos de los arquitectos de la nueva economía, de una habilidad de alta intensidad intelectual que podría considerarse equivalente al dominio de un idioma, una tarea compleja que permite a la persona interactuar y entenderse directamente con la máquina. Ser programador es un trabajo creativo, un papel indispensable en la economía de hoy que merece muchísimo respeto..."

www.d-activo.com

Desarrollo de ASP.NET, sus orígenes

dactivo — Wed, 25 Jul 2007 10:13:00 GMT

DIFICULTAD: 1. Os recomiendo esta entrevista a Scott Guthrie, director general de la División de desarrollo de Microsoft que no tiene desperdicio. Algunos momentos interesantes de la entrevista:

"entonces usted solía llamarlo ASP+. SG:Originalmente lo llamamos XSP; la gente siempre se preguntaba qué significaba la X. En ese momento, realmente no significaba nada. El XML comenzó así, al igual que el XSLT. Todo lo mejor parece empezar con una X, así que ese es el motivo por el que originalmente lo llamamos así... Creo que también tiene valor el hecho de llevar a cabo una fase de prototipo incluso antes de obtener el código de producción. Se trata de uno de los éxitos que conseguimos con ASP.NET. Dijimos que íbamos a desechar todas las líneas de código que escribiéramos en el siguiente par de meses. Nos pusimos de acuerdo en ello. No íbamos a decir: "Oh, tomemos esto y adaptémoslo, podemos limpiarlo...cuando se empieza con un proyecto o una nueva área donde no está claro cómo llegar del punto A al producto terminado, resulta tremendamente valioso el hecho de contar con un periodo dedicado al prototipo y a hacer pruebas."

www.d-activo.com

¿C almohadilla?

dactivo — Wed, 25 Jul 2007 10:13:00 GMT

DIFICULTAD: 1. A veces he oído hablar de c almohadilla para C #. En inglés se dice "C sharp", pero sharp no significa almohadilla, sino, sostenido (símbolo musical). El equívoco procede de que sus creadores al no encontrarse el sostenido en un teclado tradicional utilizan en realidad una almohadilla para expresar el sostenido. Es una equivocación hablar de c almohadilla si quiere uno hablar como sus creadores lo concibieron, ¡¡¡o c sharp o c sostenido!!! Si queréis ver alguna referencia web: http://msdn2.microsoft.com/en-us/vcsharp/aa336773.aspx www.d-activo.com

BumpTop desktop / Desktop 3D

dactivo — Wed, 25 Jul 2007 10:08:00 GMT

DIFICULTAD: 1. En una entrevista entre Steve Jobs y Bill Gates (la primera en más de 20 años de la que hablaré en otro post) en D5, que fue una conferencia sobre temas digitales del Wall Street Journal,Walt Mossberg le preguntaba o reprochaba a estos 2 gigantes del software que a pesar de lo que había avanzado la tecnología seguíamos tirando de los mismo conceptos en cuanto al escritorio y organización del ordenador, la metáfora (hablamos en estos términos sobre un ordenador) del explorador de archivos / escritorio no ha cambiado en absoluto: seguimos utilizando las carpetas con sus archivos que podemos mover de un sitio a otro dentro del espacio que nos dé el escritorio. Una buena solución es el software que nos propone Anand Agarawala. Es de lo más original...: http://www.ted.com/index.php/talks/view/id/131 Resumiendo, el concepto es crear un escritorio tridimensional, e intentar interactuar a modo de un escritorio real. Pasamos de utilizar una metáfora simploide a una imagen virtual muy aproximada a la realidad. Así visualizamos todo lo que contiene el escritorio en 3D y nos da la posibilidad de apilar archivos y carpetas, como lo hacemos en la realidad, así como lanzar los archivos contra otros como pasaría con un objeto real y crear un curioso efecto dominó. Anand, cuya conferencia está cargada de humor, dice que le gustaría tener su escritorio virtual igual de desordenado que su desktop real. Y entonces nos regala una demostración. En fin esto está repleto de ideas muy frescas, pero mirad la conferencia. No os perdáis la parte en la que nos demuestra que en su bumptop también tiene estanterías. www.d-activo.com

Cómo averiguar si un programa de consola tiene ya una ventana abierta en .NET 1

dactivo — Sat, 04 Mar 2006 10:57:00 GMT

Esta pregunta nos la hemos hecho algunos cuando se trataba de hacer un programa que sólo pudiera tener una ventana abierta a la vez, esto a veces puede ser útil por ejemplo para hacer un aplicación MDI, o porque al ser un programa único sin posibles añadidos ni cambio de pantallas, quisiéramos que no ocurriera nada.
Pues bien, éste es mi truco personal:

Process oCurrentProcess = Process.GetCurrentProcess();

//get all other process by the same name, atleast one will be returned - the current one.

Process[] arrProcesses = Process.GetProcessesByName(oCurrentProcess.ProcessName);

bool bProcess = false;

//go thru all of them

foreach(Process oProcess in arrProcesses)

{

//if the id is different, that means another process by the same name exists

if(oProcess.Id != oCurrentProcess.Id) //

{

MessageBox.Show("Another instance of the application is already running");

bProcess = true;

break;

}

if(!bProcess)

{

//if process not found, start one

Application.Run(new actualizaDB());

}

else

{

//else exit

Application.Exit();

Hasta aquí yo creo que todo se entiende, y siento no tener mucho tiempo para explicarlo con detenimiento.
Pero el caso es que pensaréis, aquí falta algo, ese algo es que la ventana del programa no se abre en estos casos, se queda minimizada.
Bueno, este truco es más difícil y requiere algo más de programación pero seguro que me agradecéis que os pase este código tan socorrido.
Ah, por cierto, en .NET 2 ha llegado a mis oídos que ya hay métodos para facilitar la tarea.

Primero crear la siguiente clase:

using System;

using System.Collections.Specialized;

using System.Diagnostics;

using System.Runtime.InteropServices;

namespace Win32APIs

    /// &ltsummary>

    /// WindowsHelper implements managed wrappers for unmanaged Win32 APIs.

    /// </summary>

    public sealed class WindowsHelper

        #region structures needed to call into unmanaged Win32 APIs.

        /// &ltsummary>

        /// Point struct used for GetWindowPlacement API.

        /// </summary>

        [StructLayout(LayoutKind.Sequential)]

            private class ManagedPt

            public int x = 0;

            public int y = 0;

            public ManagedPt()

            public ManagedPt(int x, int y)

                this.x = x;

                this.y = y;

        /// &ltsummary>

        /// Rect struct used for GetWindowPlacement API.

        /// </summary>

        [StructLayout(LayoutKind.Sequential)]

        private class ManagedRect

            public int x = 0;

            public int y = 0;

            public int right = 0;

            public int bottom = 0;

            public ManagedRect()

            public ManagedRect(int x, int y, int right, int bottom)

                this.x = x;

                this.y = y;

                this.right = right;

                this.bottom = bottom;

        /// &ltsummary>

        /// WindowPlacement struct used for GetWindowPlacement API.

        /// </summary>

        [StructLayout(LayoutKind.Sequential)]

        private class ManagedWindowPlacement

            public uint length = 0;

            public uint flags = 0;

            public uint showCmd = 0;

            public ManagedPt minPosition = null;

            public ManagedPt maxPosition = null;

            public ManagedRect normalPosition = null;

            public ManagedWindowPlacement()

                this.length = (uint)Marshal.SizeOf(this);

        #endregion

        // External Win32 APIs that we're calling directly.

        [DllImport("USER32.DLL", SetLastError=true)]

        private static extern uint ShowWindow (uint hwnd, int showCommand);

        [DllImport("USER32.DLL", SetLastError=true)]

        private static extern uint SetForegroundWindow (uint hwnd);

        [DllImport("USER32.DLL", SetLastError=true)]

        private static extern uint GetWindowPlacement (uint hwnd,

            [In, Out]ManagedWindowPlacement lpwndpl);

        [DllImport("USER32.DLL", SetLastError=true)]

        private static extern uint FindWindow (string lpClassName, string lpWindowName);

        // Windows defined constants.

        private const int WM_ACTIVATE = 0x0006;

        private const int WA_CLICKACTIVE = 2;

        private const int SW_SHOWNORMAL = 1;

        private const int SW_SHOWMINIMIZED = 2;

        private const int SW_SHOWMAXIMIZED = 3;

        private const int WPF_RESTORETOMAXIMIZED = 2;

        /// &ltsummary>

        /// Finds the specified window by its name (or caption).

        /// </summary>

        /// &ltparam name="windowName">Name of the window to find and activate.</param>

        /// &ltreturns>Window handle or 0 if window not found by that name.</returns>

        static private uint FindWindow(string windowName)

            // first, try to find the window by its window name or caption.

            uint hwndInstance = FindWindow(null, windowName);

            if (hwndInstance <= 0)

                Debug.Assert(false,

                    "Couldn't find window handle for the specified window name.");

            return hwndInstance;

        /// &ltsummary>

        /// Finds the specified window by its name (or caption).  Then brings it to

        /// the foreground.

        /// </summary>

        /// &ltparam name="windowName">Name of the window to find and activate.</param>

        static public void ActivateWindow(string windowName)

            // first, try to find the window by its window name or caption.

            uint hwndInstance = FindWindow(windowName);

            // Then, get the WindowPlacement, so we can decide the best way to

            // activate the window correctly.

            ManagedWindowPlacement placement = new ManagedWindowPlacement();

            GetWindowPlacement(hwndInstance, placement);

            if (placement.showCmd == SW_SHOWMINIMIZED)

                // if the window is minimized, then we need to restore it to its

                // previous size.  we also take into account whether it was

                // previously maximized.

                int showCmd = (placement.flags == WPF_RESTORETOMAXIMIZED) ?

                    SW_SHOWMAXIMIZED : SW_SHOWNORMAL;

                ShowWindow(hwndInstance, showCmd);

            else

                // if it's not minimized, then we just call SetForegroundWindow to

                // bring it to the front.

                SetForegroundWindow(hwndInstance);

}

Después cread esta otra clase:

using System;

using System.Collections.Specialized;

using System.Reflection;

using System.Threading;

using System.Windows.Forms;

using Win32APIs;

namespace SingleInstanceApp

    /// &ltsummary>

    /// SingleInstanceHelper implements functionality to create single instance

    /// WinForms applications.

    /// </summary>

    public sealed class SingleInstanceHelper

        // private member data.

        static private Mutex singleInstance = null;        // holds the mutex for this application.

        // private constants.

        private const string formatMutexName = "SingleInstanceMutex-{0}-{1}";

        /// &ltsummary>

        /// Generates a unique identifier for this application's mutex based on its

        /// assembly name and version.

        /// </summary>

        static private string UniqueIdentifier

get

                string appName = "";

                string appVersion = "0.0.0.0";

                Assembly entry = Assembly.GetEntryAssembly();

                if (entry != null)

                    AssemblyName assemblyName = entry.GetName();

                    if (assemblyName != null)

                        appName = assemblyName.Name;

                        appVersion = assemblyName.Version.ToString();

                return string.Format(formatMutexName, appName, appVersion);

        /// &ltsummary>

        /// Proxy method used by WinForm apps that want single instance behavior.

        /// This method will check if this is the first instance and create a new form of the

        /// specified type.  Otherwise, it will find the currently running instance and bring it

        /// to the foreground.

        /// </summary>

        /// &ltparam name="newFormType">Type of the form to create if this is the first instance.</param>

        static public void ProxyMain(Type newFormType, string windowName)

            // first, we create an instance of the Mutex with the appropriate identifier

            // for this app.

            singleInstance = new Mutex(false, UniqueIdentifier);

            // then, we attempt to lock the Mutex to see if its the first intance.

            // a Mutex can only ever have one lock on it at a time.

            if (singleInstance.WaitOne(1, true))

                // if this is the first instance, then create an instance of the main Form.

                // we use the specified type and reflection to call the default constructor

                // for the Form using Reflection.  That way this class is reuseable for any

                // applications you'd like to use it on.

                ConstructorInfo constructor = newFormType.GetConstructor(Type.EmptyTypes);

                Form newForm = (Form)constructor.Invoke(null);

                Application.Run(newForm);

            else

                // if its not the first instance, then bring the first one to the foreground.

                WindowsHelper.ActivateWindow(windowName);

}

Y el form donde vayáis a utilizarlo colocad lo siguiente:

using System;

using System.Diagnostics;

using System.Drawing;

using System.Collections;

using System.ComponentModel;

using System.Windows.Forms;

namespace SingleInstanceApp

    /// &ltsummary>

    /// Summary description for FormSingleInstanceApp.

    /// </summary>

    public class FormSingleInstanceApp : System.Windows.Forms.Form

        // private constants;

        private const string windowName = "Single Instance App";

        // Windows Form Designer generated member data.

        private System.Windows.Forms.Label label1;

        private System.Windows.Forms.Label labelCurrentProcess;

        /// &ltsummary>

        /// Required designer variable.

        /// </summary>

        private System.ComponentModel.Container components = null;

        public FormSingleInstanceApp()

//

            // Required for Windows Form Designer support

//

            InitializeComponent();

        /// &ltsummary>

        /// Clean up any resources being used.

        /// </summary>

        protected override void Dispose( bool disposing )

            if( disposing )

                if (components != null)

                    components.Dispose();

            base.Dispose( disposing );

        // Windows Form Designer generated code removed for brevity...

        /// &ltsummary>

        /// The main entry point for the application.

        /// </summary>

        [STAThread]

        static void Main(string[] args)

            SingleInstanceHelper.ProxyMain(typeof(FormSingleInstanceApp), windowName);

        private void FormSingleInstanceApp_Load(object sender, System.EventArgs e)

            Process currentProcess = Process.GetCurrentProcess();

            if (currentProcess != null)

                this.labelCurrentProcess.Text = currentProcess.Id.ToString();

}