Saturday, September 30, 2006

Programacion de juegos desde cero

En programacion encontramos diferentes ramas (por llamarlas de alguna manera), cada una requiere diferentes habilidades, para nombrar algunos ejemplos tenemos:

  • Sistemas Operativos
  • Dispositivos
  • Controladores (drivers)
  • Anti-virus
  • Virus
  • Frameworks (como .NET por ejemplo)
  • Programacion de juegos

Aun solo dentro de Windows, podriamos hablar de diferentes categorias:

  • Windows Nativo
  • Managed
  • Web Services
  • programacion paginas Web
  • etc...

La programacion de juegos es una de las ramas que requiere mas conocimiento en varios temas diferentes que (y normalmente ademas de) programacion tradicional.

Programacion de juegos es algo que siempre ha despertado mi interes, pero lo mas que hecho es un par de juegos en modo texto y un juego de domino que se puede jugar en red; como parte de mi interes en este tema, he estudiado OpenGL, DirectX, incluso llegue a escribir algunos articulos acerca de OpenGL con Delphi

He leido bastante sobre programacion de juegos en general, lo suficiente como para saber que tu primer juego debe ser algo simple, la mayoria de la gente que quiere adentrarse en el tema se avientan a crear algo grande con animaciones en tercera dimension tipo HALO; por supuesto, la mayoria de las personas... fracasan.

Debes saber que lo mas seguro es que casi nadie va a querer jugar tus primeras creaciones (ni tus mismos amigos), asi que seria buena idea que hicieras esto con alguien mas, ya que el factor motivacion juega un papel muy importante, y es muy facil desanimarse porque a nadie le interesa lo que hacemos

Los que ya saben de estas cosas recomiendan que crees algo como un Tetris para tu primer juego, ya que aun siendo este un juego muy simple (visto desde el punto de vista de complejidad tecnica), contiene todos los elementos de cualquier juego

  • entrada
  • logica
  • animacion
  • niveles
  • ciclo de juego (todo juego tiene un ciclo de juego)

Otras buenas opciones para tu primer juego serian los famosos steroids, bricks, pac-man, etc. Si necesitas mas ideas, puedes visitar sitios como latingames, donde encontraras cientos de juegos flash, incluso puedes escribir una version mas simple del juego que elijas, la idea es que debe ser suficientemente simple para que te permita terminarlo, una vez que termines la primera version, talvez puedes extenderlo, pero de alguna manera ya habrias escrito tu primer juego, y eso es realmente importante para tu motivacion.

Escribir un juego "desde cero" estos dias es mucho pero muy lejano a lo que era hace solo unos cuantos años, cuando tenias que crear todo, algunas veces hasta tus mismos formatos para guardar los modelos, por supuesto el codigo para cargar tus formatos, y cada pixel que querias dibujar en la pantalla, tenias que escribir codigo para lograrlo; los años han pasado y ahora tenemos formatos estandares para modelos, sonidos, graficas, etc. y lo mas importante es que ahora contamos con muchisimos frameworks que te permiten escribir juegos mucho mas facil.

Uno de los mas recientes frameworks es XNA; uno podria comparar XNA para programacion de juegos, mas o menos como Visual Studio es para programacion en C#, ya que este nos permite concentrarnos en el juego en si (tema, logica, etc), dandonos toda la funcionalidad para hacer la mayoria de salida de graficas, sonido, entrada/salida de teclado, etc; una de las cosas mejores que tiene este framework es que te permitira correr tus propios juegos en tu XBox 360, dificil encontrar algo mejor que eso.

Un par de amigos y yo hemos decidido aventarnos a escribir juegos meramente por diversion (y por aprender mas claro), talvez empecemos con un pac-man simple; aunque planearemos en hacerlo extensible, comenzaremos con algo realmente simple.

Una idea mas o menos de lo que tenemos en mente, si es que nos decidimos por el pac-man, seria mas o menos:

  • Un solo "mundo"
  • un solo nivel
  • un solo tipo de monstruo (fantasma o lo que sea)
  • Lo mas seguro es que nosotros mismos crearemos nuestros graficos en Paint y grabaremos nuestros propios sonidos (esto podria ser divertido)

Las partes donde podriamos permitir extensibilidad podrian ser

  • un modelo plugin para crear nuevos fantasmas
  • modelo plugin que permita crear nuevos mundos y niveles

Suena bastante simple y podriamos extendernos tanto como quisieramos, pero primero hay que llegar a la version 1

Ya les estare platicando aqui en el blog mis experiencias (y codigo fuente) creando este primer juego, realmente espero no fallar como muchos han fallado antes. Tambien como muchos antes que yo, espero que, si no te puedo ayudar, al menos pueda inspirar a uno que otro para que se lancen al mundo maravilloso de programacion de juegos

Si quieren seguir la aventura conmigo, pueden empezar por bajarse XNA y Visual Studio 2005 edicion Express, tambien seria bueno que te bajaras este tutorial, si no entiendes mucho ingles, pues al menos te avientas a estudiar el codigo fuente, este contiene la mayoria de los elementos basicos y te permitira familiarizarte con XNA.

hasta la proxima

Thursday, September 28, 2006

google reader por fin tiene una interfaz de usuario decente

He estadousando google reader por un par de meses, y para ser honesto era una de las peores interfaces de usuario que he usado hasta hoy, pero ahorita acabo de entrar a checar mis blogs y me topo con una agradable sorpresa, por fin tiene una interfaz de usuario normal que permite agrupar tus feeds en folders y te muestra cuantos te faltan por leer en cada categoria y esas cosas de un RSS reader normal...

Si te pasa como a mi que lees tus blogs en varias maquinas (y por si has vivido bajo tierra en los ultimos años, ahora no tienes que ir a visitar las paginas, sino usar un RSS reader donde te llegan los nuevos posts como emails), te recomiendo que uses google reader, no hay que bajar nada, todo se mantiene en la web para que lo acceses de tu casa, trabajo, escuela, etc. checalo aqui

Monday, September 25, 2006

Fabrica generica para el patron de creacion sencillo en C#

La ultima vez les presente el simple factory pattern usando diccionarios de metodos en C# y tambien les conte de la implementacion (mucho mas elegante y generica) que Steven escribio; con la cual ya no necesitamos escribir una fabrica nueva para cada serie de productos, sino que podemos usar esta fabrica para cualquier producto que tengamos. Aun cuando la generacion dinamica de codigo esta muy suave, yo me quede inquietado con la idea de que tal vez habia una manera mas facil de lograr esa misma tarea, finalmente me llego la inspiracion y escribi una version mucho mas corta. Aqui esta:

public static class SimpleStaticGenericFactory<TKey, TBaseType> where TBaseType : class {
public delegate TBaseType BaseTypeInvoker();
private static Dictionary<TKey, BaseTypeInvoker> methods =
new Dictionary<TKey, BaseTypeInvoker>();
public static void Add(TKey key, BaseTypeInvoker instantiatorMethod) {
if (!methods.ContainsKey(key))
methods.Add(key, instantiatorMethod);
}
public static void CreateInstance(TKey key) {
if (methods.ContainsKey(key))
methods[key]();
else //what would you like to do in this case?
throw new ArgumentException(string.Format("{0} not found", key));
}
}

Eso es todo!, o si prefieres la version no-estatica:

public class SimpleGenericFactory<TKey, TBaseType> where TBaseType : class {
public delegate TBaseType BaseTypeInvoker();
private Dictionary<TKey, BaseTypeInvoker> methods =
new Dictionary<TKey, BaseTypeInvoker>();
public void Add(TKey key, BaseTypeInvoker instantiatorMethod) {
if (!methods.ContainsKey(key))
methods.Add(key, instantiatorMethod);
}
public void CreateInstance(TKey key) {
if (methods.ContainsKey(key))
methods[key]();
else //what would you like to do in this case?
throw new ArgumentException(string.Format("{0} not found", key));
}
}

Realmente *no necesitamos* el metodo CreateInstance, podriamos llamar los metodos directamente si el diccionario fuera publico, pero no seria muy buena idea dar acceso abierto al diccionario (aunque con refleccion se puede lograr, pero ya les contare). Usando el ejemplo de los reportes que he venido usando, podriamos usar esta fabrica generica de la siguiente manera:

SimpleStaticGenericFactory<string, BaseReport>.Add("report1", delegate() { return new Report1(); });
SimpleStaticGenericFactory<string, BaseReport>.Add("report2", delegate() { return new Report2(); });
SimpleStaticGenericFactory<string, BaseReport>.CreateInstance("report1");
o usando la version no-estatica:
SimpleGenericFactory<string, BaseReport> reports1 =
new SimpleGenericFactory<string, BaseReport>();
reports1.Add("report1", delegate() { return new Report1(); });
reports1.Add("report2", delegate() { return new Report2(); });
reports1.CreateInstance("report1");
simple, sencillo y elegante; voy a escribir un ejemplo de un modelo plug-in que utilice esta fabrica para que vean lo flexible de esta fabrica generica.

kick it on DotNetKicks.com

Saturday, September 23, 2006

Simple factory pattern usando diccionarios de metodos en C#

He estado hablando de arreglos de metodos, diccionarios de metodos, como ambas tecnicas son muy similares en la implementacion, cuando puedes usar una u otra y un ejemplo practico del patron de creacion simple usando arreglos de metodos. Hoy les mostrare la implementacion de este patron usando diccionarios de metodos y luego ya blogueare sobre cosas mas interesantes, Steven posteo una implementacion de este mismo paterno, pero mucho mas elegante usando tipos genericos y generacion dinamica de codigo usando ILGenerator, aun asi pongo el codigo aqui para dejar un ejemplo mas de como usar los diccionarios de metodos.

using ReportCreatorDictionary = Dictionary<string, ReportCreatorDelegate>;
//Este es nuestro producto base
abstract class BaseReport {
public BaseReport() {
Console.WriteLine("Base Report Created");
}
public abstract void Execute();
}
//producto 1
class Report1 : BaseReport {
public Report1():base() {
Console.WriteLine("Report1 created");
}
public override void Execute() {
Console.WriteLine("Report1");
}
}
//producto 2
class Report2 : BaseReport {
public Report2():base() {
Console.WriteLine("Report2 created");
}
public override void Execute() {
Console.WriteLine("Report2");
}
}

delegate BaseReport ReportCreatorDelegate();
//esta es la fabrica
class ReportGenerator {

static BaseReport CreateReport1() {
return new Report1();
}

static BaseReport CreateReport2() {
return new Report2();
}

static ReportCreatorDictionary reports;

static ReportGenerator() {
reports = new ReportCreatorDictionary();
reports.Add("Report1", new ReportCreatorDelegate(CreateReport1));
reports.Add("Report2", new ReportCreatorDelegate(CreateReport2));
}

public static BaseReport Execute(string reportType) {
return reports[reportType]();
}
}

y la forma de usarlo:

BaseReport report1 = ReportGenerator.Execute("Report1");
report1.Execute();

BaseReport report2 = ReportGenerator.Execute("Report2");
report2.Execute();

Por supuesto que la opcion del reporte que queremos ejecutar puede venir de donde sea (un drop down list, un link en una pagina web, configuracion, etc)


El problema con esta implementacion, como lo menciona Steven, es que tienes que cambiar la fabrica cada que agregas un producto nuevo, y no es flexible como para permitir un modelo de plug-in, porque todos los tipos se necesitan conocer al tiempo de compilar; y si necesitas una fabrica para crear otra serie de productos tienes que escribir una nueva fabrica (pues claro!!... podria pensar uno). Pues resulta que con la implementacion de Steven ya no necesitas escribir una fabrica nueva, sino que el escribio una fabrica generica que puedes reusar con cualquier producto, solo le agregas los productos, internamente esta crea los metodos necesarios para crear la instancia del producto que agregaste, y esta lista para usarse, realmente esta muy interesante, te recomiendo que la leas (aunque solo esta en ingles =o( )


El codigo de Steven me ha dado otra idea, tendre que ver si funciona asi como me lo imagino y luego ya posteare sobre el tema


Por ahora, aqui esta el codigo completo para los diccionarios de metodos y este ejemplo de la fabrica; como siempre, juega con el codigo, muevele, quiebralo, mejoralo

Extension "bloguear esto" para Interner Explorer se integra con Live Writer

Hace unos dias leia en el blog de Geoff que le ha gustado mucho el Live Writer y que es la herramienta que usa para bloguear, yo le comente que yo extrañaba la funcionalidad "blog this" de Flock; bueno, pues Geoff escribio una extension para IE que agrega esta funcionalidad y te permite escribir tus blogs en Live Writer, mas o menos asi como lo hace Flock, pero por supuesto con todo lo que tiene Live Writer

Aparte de eso, tambien aprendi algo nuevo, yo no sabia que era tan facil crear una extension para IE, solamente usando JavaScript y unas llaves en el registro de Windows, incluso lo podrian hacer en español facilmente, si estan en la onda del blogueo les recomiendo esta extension, chequenlo aqui

Practicas basicas de un buen desarrollador

He estado bastante ocupado ultimamente haciendo mucho trabajo de refactorizacion, pero espero pronto regresar a postear sobre cosas interantes de C# como tipos genericos y patrones

Por mientras, he estado leyendo mi pila de blogs acumulados, y me encontre este blog post de Jeremy Miller, ahi expone algunos puntos que en lo personal siempre trato de apegarme a ellos

  • No tolerar codigo mediocre
  • No escribir codigo sobre codigo malo
  • Arreglar siempre un build que no funcione
  • No quitarse nunca el "sombrero de desarrollador"
  • Importa la calidad? Absolutamente

Para mi estas cosas son mas basicas incluso que probar el codigo, si sigues estas simples guias, tus pruebas de codigo correran mucho mas facil.

No tolero codigo mediocre y no tolero desarrolladores que escriben codigo mediocre, ni siquiera tolero tener warnings en mi codigo.

Siempre vamos a encontrar gente en nuestros equipos de trabajo que no son muy buenos en apegarse a los principios basicos (y no estoy hablando acerca de mi equipo de trabajo actual, en caso de que ellos lean esto), y uno tiene que aprender a lidiar con esta gente, si eres el lider de equipo eso es parte de tu trabajo, tienes que mostrarles el uso de tecnicas mejores o patrones de desarrollo, yo se que es dificil tratar con desarrolladores, especialmente si tu eres mas joven que ellos; si no eres el lider del grupo es aun mas dificil, pero lo que puedes hacer simplemente es ser un ejemplo para los demas, si sigues estas practicas seguramente te convertiras en mejor desarrollador que alguien que no las sigue, la gente eventualmente vera eso en ti y empezaran a escucharte en algun momento, solo hay que tener bastante paciencia y mucha perseverancia

Los directivos muchas veces se asustan si oyen que estas haciendo refactoring, reorganizando (incluso reescribiendo) el codigo, etc, pero eso no te debe detener (incluso puede que tengas que hacerlo en tu propio tiempo, despues de horas de trabajo), despues de todo, solo estaras haciendote la vida mas facil tu mismo y mejorando las cosas para tu equipo

Rootkits escondidos en Codecs

Creo que esto va a hacer caer a muchisima gente (texto en ingles solamente)

Estas navegando en internet, y encuentras un video que quieres ver (no, no uno de esos videos... bueno, no necesariamente), pero dice que tienes que instalar un codec. Codec es un codificador / decodificador de video que es usado para hacer los archivos de video mucho mas manejables. Instalas el codec y luego ves el video, o talvez no lo ves, pero que crees? te instalaron un rootkit! Ahora, de cierto modo, esa es la clasica trampa para infectarte con un virus o troyano, pero los detalles son muy interesantes

Hay que tener mucho cuidado

Wednesday, September 13, 2006

magia de photoshop

Verdaderamente increible lo que puede hacer alguna gente armada con Photoshop (click en la foto para ver mas de estas creaciones)

Internet Explorer 7 en español

Para los que les gusta tener las herramientas en su idioma, aqui esta el IE7 en español, yo he venido usando esta version (pero en ingles) y la verdad es que esta muy bueno, le agregamos la busqueda incremental y listo =o)

Tuesday, September 12, 2006

Busqueda incremental en Internet Explorer "a la Firefox"

Aunque muchos descubrieron este tipo de busqueda en Firefox, la verdad es que fue implementado mucho antes... pero bueno, la cosa es que alguien escribio un plugin para IE que nos permite tener esto mismo en IE

Find as you type

Dictionarios de metodos en C#

Este articulo es en seguimiento a mi articulo anterior arreglos de metodos en C#, en algunos de los comentarios mencionaron que es posible implementar esta tecnica usando diccionarios, alguien por ahi incluso puso el codigo completo usando diccionarios, de cualquier manera queria subrayar algunas de las diferencias y señalar donde podriamos usar una u otra alternativa (que deberia ser obvia, pero he aprendido que no hay tal cosa como algo obvio)

En los diccionarios podemos guardar datos de la forma <Key, Value>, asi que podemos guardar un int, string o lo que sea, en el Key, y en el value podemos poner el puntero hacia el metodo que queremos ejecutar; en contraste, cuando usamos arreglos de metodos, estamos limitados a usar tipos de datos que pueden ser convertidos a enteros para accesar nuestros metodos.

Vamos a ver el ejemplo previo y como cambia para adaptarlo a usar diccionarios, los cambios -como veran- son minimos para migrar de una a otra alternativa

- La declaracion del delegado no cambia

- Ahora, en vez de un arreglo, tenemos un diccionario, algo asi mas o menos:

Dictionary<int, AddStringDelegate> addStringMethods;

- La declaracion de los metodos es la misma


- El codigo para agregar los metodos al diccionario es un poquito diferente:

addStringMethods = new Dictionary<int, AddStringDelegate>(4);
addStringMethods.Add((int)StringType.Type1, new AddStringDelegate(AddStringType1));
addStringMethods.Add((int)StringType.Type2, new AddStringDelegate(AddStringType2));
addStringMethods.Add((int)StringType.Type3, new AddStringDelegate(AddStringType3));
addStringMethods.Add((int)StringType.Type4, new AddStringDelegate(AddStringType4));

- The implementation to use the methods remains exactly the same

public void AddString(string someValue, StringType stringType) {
addStringMethods[(int)stringType](someValue);
}

Listo! asi que solo tuvimos que cambiar un par de cosas y ya estamos usando diccionarios en vez de arreglos.


Entonces, cuando debo usar diccionarios en vez de arreglos? basicamente, cuando los necesites; los arreglos son mucho mas simples y livianos, los diccionarios agregan algo de peso pero te dan mas flexibilidad, por ejemplo si quieres usar un string para accesar el metodo, entonces puedes usar el diccionario; los diccionarios tambien te permiten agregar/borrar, ahorita no se me ocurre porque querrias hacer eso, pero se puede hacer. Yo diria que si tienes un numero entero con el que puedes accesar el metodo que necesitas, usa el arreglo, realmente no necesitas usar diccionarios en ese caso.


Si nadie (de mis 3 lectores) me gana, correre unas pruebas usando ambas opciones y vere si hay alguna diferencia relevante en velocidad, y posteare los resultados aqui. Si tu haces las pruebas, y lo pones en tu blog, y yo me entero, entonces incluire un link aqui solo para dar seguimiento a esta onda


Aqui esta el codigo completo, quitale, agregale, cambiale, hazlo mejor

class FileGeneratorBase {

Dictionary<int, AddStringDelegate> addStringMethods;

public FileGeneratorBase() {
addStringMethods = new Dictionary<int, AddStringDelegate>(4);
addStringMethods.Add((int)StringType.Type1, new AddStringDelegate(AddStringType1));
addStringMethods.Add((int)StringType.Type2, new AddStringDelegate(AddStringType2));
addStringMethods.Add((int)StringType.Type3, new AddStringDelegate(AddStringType3));
addStringMethods.Add((int)StringType.Type4, new AddStringDelegate(AddStringType4));
}

public void AddString(string someValue, StringType stringType) {
addStringMethods[(int)stringType](someValue);
}
void AddStringType1(string someValue) {
OutputText(string.Format("String Type 1: {0}", someValue));
}
void AddStringType2(string someValue) {
OutputText(string.Format("String Type 2: {0}", someValue));
}
void AddStringType3(string someValue) {
OutputText(string.Format("String Type 3: {0}", someValue));
}
void AddStringType4(string someValue) {
OutputText(string.Format("String Type 4: {0}", someValue));
}
void OutputText(string someValue) {
Console.WriteLine(someValue);
}
}

class Program {
static void Main(string[] args) {
//*** Arrays of methods demo
FileGeneratorBase fg = new FileGeneratorBase();
fg.AddString("some value", StringType.Type1);
fg.AddString("some other value", StringType.Type2);
fg.AddString("one last value", StringType.Type3);
fg.AddString("testing out of bounds", StringType.Type4);
Console.ReadLine();
}
}

En mi siguiente articulo te mostrare la implementacion de esta tecnica aplicada al patron de creacion simple, solo para cerrar el ciclo en este tema.

Saturday, September 09, 2006

Simple factory pattern hecho mas simple

El "Simple Factory pattern" (algo asi como patron de creacion simple) regresa una instancia de varias posibles, dependiendo de los parametros que le pasemos a este.

La semana pasada hablaba de una tecnica que te permite reducir (y reusar efectivamente) tu codigo, cuando tienes un patron de 2 o mas valores, donde por cada valor quieres ejecutar un metodo diferente de la misma estructura, algo mas o menos asi:

if (someValue == SomeEnum.Type1)
  Method1("value 1");
else if (someValue == SomeEnum.Type2)
  Method2("value 2");
else if (someValue == SomeEnum.Type2)
  Method3("value 3");

Mientras que este metodo es valioso por si mismo, hay un patron donde se acomoda perfectamente, este patron es el "Simple factory pattern"; vamos a ver un ejemplo usando unos reportes ficticios

Supongamos que tenemos una clase base, y dos implementaciones de esta:

abstract class BaseReport {
public BaseReport() {
Console.WriteLine("Base Report Created");
}
public abstract void Execute();
}
class Report1 : BaseReport {
public Report1():base() {
Console.WriteLine("Report1 created");
}
public override void Execute() {
Console.WriteLine("Report1");
}
}
class Report2 : BaseReport {
public Report2():base() {
Console.WriteLine("Report2 created");
}
public override void Execute() {
Console.WriteLine("Report2");
}
}

enum ReportType {
Report1,
Report2
}

Para usar arreglos de metodos, declaramos un delegado que servira para crear las instancias de los reportes:

delegate BaseReport ReportCreatorDelegate();

Luego tenemos la clase implementadora que contiene:



  • Un arreglo de metodos
  • Un metodo para crear cada reporte
  • El metodo para ejecutar el reporte que necesitemos, dependiendo de los parametros
class ReportGenerator {
static BaseReport CreateReport1() {
return new Report1();
}
static BaseReport CreateReport2() {
return new Report2();
}
static ReportCreatorDelegate[] reports;
static ReportGenerator() {
reports = new ReportCreatorDelegate[2];
reports[0] = new ReportCreatorDelegate(CreateReport1);
reports[1] = new ReportCreatorDelegate(CreateReport2);
}
public static BaseReport Execute(ReportType reportType) {
return reports[(int)reportType]();
}
}

Como pueden ver el codigo ese simple, hay una simple linea que ejecuta el reporte que necesitamos, dependiendo del enum que le pasemos, aqui esta un ejemplo del uso del codigo:

BaseReport report1 = ReportGenerator.Execute(ReportType.Report1);
report1.Execute();

BaseReport report2 = ReportGenerator.Execute(ReportType.Report2);
report2.Execute();
Console.ReadLine();

Algo importante que notar, aqui en este ejemplo yo estoy pasando el enum para el reporte que quiero ejecutar, alguien me dijo en mi otro blog (en ingles) que no tenia caso tener el patron, que ahi directamente podia yo crear la instancia; en este caso especificamente si podria ser asi, pero el valor del enum para el reporte que queremos ejecutar podria venir de un drop down list, de la configuracion, de una llamada a un web service, etc


Este ejemplo particular es realmente liviano y funciona muy bien para implementar este paterno, pero tiene la limitacion de que solo funciona para valores que pueden ser convertidos a tipos numericos enteros


Ayende y Steven correctamente mencionaron en mi otro blog que la misma tecnica puede ser implementada usando diccionarios, esto nos permitiria usar otros tipos de datos como el indice de nuestra coleccion de metodos


En mis siguientes posts hablare de como implementar esa tecnica de usar diccionarios de metodos, realmente es muy similar a esta


Por ahora pueden encontrar todo el codigo para este y el ejemplo previo aqui

Friday, September 08, 2006

Como instalar mas de una version de Turbo Explorer

Este chavo creo un programita que permite combinar varios productos Turbo Explorer (por default solo se puede instalar uno de los productos)

los pasos, segun Andy:

1. Instalar la primera personalidad de Turbo Explorer con el instalador normal que te bajaste.
2. Extraer la siguiente personalidad del instalador Turbo Explorer.
3. Correr TurboMerger.exe y seleccionar el directorio donde extra(j|g)iste la segunda personalidad del instalador de Turbo Explorer. Presiona el boton "Install". En el instalador de InstallShield no cambies los directorios. Si hace esto destrozaras la instalacion de Turbo Explorer.
4. Regresar al paso 2 hasta que hallas instalado todas las personalidades que quieras.

donde se encuentra Delphi en estos momentos

Daniel Wichnewski acaba de poner en su blog el numbero de downloads para los productos turbo explorer, hasta ahorita solo son unos cuantos miles; estos son los numeros mas significativos:

turbocpp.exe: 464
turbocpp_de.exe: 348

 

turbocsharp.exe: 232
turbocsharp_de.exe: 226

 

turbodelphi.exe: 766
turbodelphi_de.exe: 851

turbodelphi4net.exe: 200
turbodelphi4net_de.exe: 266

Delphi para .NET no parece tener mucha popularidad, y probablemente algunos lo bajaron solo por mera curiosidad

Thursday, September 07, 2006

Encontrando grandes desarrolladores

Joel habla acerca de sus experiencias contratando desarrolladores y lo dificil que es conseguir los realmente buenos, el punto principal -de acuerdo a Joel- es que los grandes desarrolladores ya estan trabajando en algun lugar, asi que normalmente no estan disponibles y la mayoria de los curriculums que llegan son de los programadores chafas (malos)

Los grandes desarrolladores, de hecho, la mejor gente en cada area, simplemente nunca estan en el mercado.

El gran desarrollador promedio aplicara talvez a cuatro empleos en toda su carrera.

Eso quiere decir que voy bien, aun estoy en mi primer trabajo =o)

Yo he tenido discusiones con compañeros de trabajo sobre este mismo tema, mientras que yo comparto el punto de opinion de Joel, hay alguna gente que cree que no es dificil conseguir buenos desarrolladores

Personalmente soy de la idea de que de cada generacion de ingenieros de sistemas sale uno o dos buenos desarrolladores (los grandes son mucho mas raro que eso)

Joel luego describe como podrias conseguir algunos de esos grandes desarrolladores:

  • Ir a la montaña
  • Internados
  • Construir tu propia comunidad*
  • Creo que eso deja fuera a practicamente todas las compañias pequeñas y medianas, no habria forma de que podrian pagar algo asi (como los internados que hace Joel)

    Luego cierra el articulo listando algunos problemas que te podrias encontrar si usas referencias de tus empleados

    Desafortunadamente para mi, nunca he conocido a un gran desarrollador, me hubiera gustado conocer a alguno, se que hubiera aprendido mucho y muy rapido; he conocido muy poquitos que considero buenos desarrolladores, pero creo que la cosa depende de los estandares de cada uno, que tan apasionado seas por el desarrollo, que tan bueno tu mismo eres.

    Ayende describe el desarrollo como arte, eso lo describe bastante bien para mi, yo creo que se requiere talento, y como tal, uno nace con este, claro que puedes aprenderlo tambien, pero nunca serias tan bueno como alguien que nacio con ese talento

    Este post no hace justicia al articulo de Joel, Joel ha estado en el negocio por un buen rato, el sabe una o dos cosas sobre desarrolladores J, vayan chequense el articlo, por ahora solo esta en ingles, pero seguro pronto encontraran la traduccion aqui

    Wednesday, September 06, 2006

    XML Notepad

    recorriendo mis blogs (los que leo) me encontre con esta herramienta

    XML Notepad 2006 provee una interface de usuario simple e intuitiva para leer y editar archivos XML.

    Definitivamente una mas para tenerlo ahi en nuestra caja de herramientas

    Los Turbos estan de regreso

    No es precisamente noticia de ultima hora pero bueno, se acuerdan de Turbo Pascal y Turbo C?, pues despues del fiasco de Borland que casi acabo con Delphi, ahora los chavos de "DevCo" (el nombre no oficial usado temporalmente hasta que se defina quien compro Delphi) han estado trabajando bastante duro y tratando de volver Delphi a la vida, como parte de esta estrategia acaban de sacar versiones gratis de Delphi, C++ y C#

    Y en todo esto que hay para ti? pues si estas usando Visual Studio para .NET 1.X no mucho, si estas usando .NET 2.0 (practicamente) nada, pero si aun necesitas crear aplicaciones en Windows 98 - Windows 2003 no hay nada mejor que Delphi. Delphi es por mucho el mejor ambiente de desarrollo que te permite crear aplicaciones rapidas muy rapido =o) 

    Nota importante! Solo se puede instalar una edicion de Turbo Explorer por maquina, asi que asegurate de bajar e instalar la que mas te interese!

    Es gratis y es el mejor, ahi no te puedes equivocar

    La pagina para bajarselo esta aqui