Velneo lo conocí en su versión 6.3.9, hace medio año aproximadamente cuando empecé a dar mis primeros pasos como programador profesional. Mi experiencia con Velneo ha sido más que satisfactoria; hice mi primera pequeña aplicación en menos de una semana, utilizando objetos de casi todo tipo incluyendo pequeños procesos, tablas y enlaces de distintos tipos que me dejaron boquiabierto en más de una ocasión (los hermanos contiguos, singular a plural y sobretodo los enlaces indirectos con los que sencillamente aluciné en colores). No me considero una persona demasiado inteligente, no más de lo estrictamente normal; creo que el secreto está en una buena base de programación y bases de datos, la curva de aprendizaje de Velneo casi plana y el considerable ahorro de desarrollo del que se encarga Velneo.

Debo decir que Velneo no debería ser comparado con productos que no se pueden considerar herramientas CASE o lenguajes de cuarta generación. Productos como Visual Basic, Delphi y parte de la filosofía .NET no sé si se podría considerar “de cuarta generación” pues para mí las herramientas CASE son aquellas que se implican en una programación asistida _real_ no simplemente en la gestión de ventanas, eventos y paso de mensajes o comunicación con SGBDs extenos. Velneo, si se compara con lo anterior, supone una revolución en el mundo del desarrollo de software de gestión pues el concepto de “programación asistida” se lleva casi al extremo.

Para empezar, el tamaño de los ficheros binarios generados por el compilador de Visual Basic resultan un tanto grandes. Ello unido a la dependencia de librerías dinámicas que en muchos casos hace un engorro la ejecución de software realizado en VB sobre ordenadores cliente donde no esté instalado la suite Visual Studio. Con Velneo la instalación y puesta a punto del software es bastante más sencilla y transparente, además de que el tamaño de los ficheros ejecutables (.vam) resulta mucho menor en comparación con VB gracias a la compresión de datos.

Por otra parte, la rapidez con la que se ejecutan aplicaciones VB es en muchos casos lenta. La experiencia que tengo en Velneo es que el tiempo de espera entre éste y VB es menor: hacer doble click sobre el icono de la aplicación, establecer la conexión con el Velneo vMotor, iniciar la aplicación con sus procesos de inicialización. Para mí Velneo supera a VB en inicialización y tiempos de espera en el uso del programa.

Además, la dependencia de herramientas y software externo en VB se dispara en comparación con Velneo, donde todo está integrado (incluso el desarrollo web dinámico se puede llevar todo dentro del mismo proyecto software). Con VB estás a merced de las raras cadenas de conexión, distintos sistemas gestores de bases de datos y/o librerías de terceros.

Hablando en términos de bases de datos, con VB sólo puedes atacar un mismo modelo de información: el Entidad/Relación. En Velneo dispones del modelo Relacional Avanzado que forma la base del desarrollo de aplicaciones con Velneo y, por otro lado, también puedes atacar bases de datos relaciones. Digamos que con VB tendrás que hacerte amigo del SQL te guste o no, en Velneo con tener claro qué quieres hacer suele ser suficiente.

Otro tema es el antiguo concepto de los componentes OCX de Visual Basic; siempre me resultó un poco engorroso. La programación de componentes de software para la posterior construcción de aplicaciones en base a módulos es en teoría una idea muy buena y un buen planteamiento de hacer las cosas desde un principio. Pero se debería utilizar POO, diseño de componentes “por contrato”, programación genérica, etc. Utilizar componentes OCX de terceros resultaba complicado porque en muchas ocasiones fallaban, hacer los tuyos propios no era fácil ya que VB realmente no está pensado para el diseño de componentes. En Velneo no hay tantos problemas; hoy en día se dispone del Almacén de Objetos que te permite importar toda clase de objetos: tablas, relaciones, variables, formularios, tablas, rejillas, etc. Aunque la finalidad de los OCX y el Almacén de Objetos no es del todo igual, el Almacén de Objetos sí permite al desarrollador ahorrar muchísimo tiempo; de cara a hacer aplicaciones de gestión es mucho más útil.

Con VB debes tener mucho más cuidado a la hora de llevar el control de los tipos de datos y la gestión de errores en tiempo de ejecución porque no sabes con qué te va a salir el usuario final (ponte en lo peor y acertarás, casi tan cierto como el “divide y vencerás”). La robustez de una aplicación final en Velneo es infinitamente superior a la de otra escrita en VB. Los errores en tiempo de ejecución, con VB, se multiplican y además no existe un verdadero control de excepciones (mejor dicho, no existe en absoluto). En la mayoría de los casos, con VB te tienes que amparar en el uso de sentencias GOTO (los famosos “On Error”) y rezar para que no se te haya pasado por alto ningún caso donde el programa pudiera romperse. Velneo proporciona binarios a prueba de bombas y rara vez nos encontraremos con que el ejecutor de aplicaciones de Velneo se cierre de manera inesperada o devuelva un mensaje de error y de que se cerrará.

Aunque VB es fácil de aprender, su sintaxis se vuelve infumable. Personalmente no me gusta, a parte de resultarme antiestética me hace escribir código espaguetti desde el principio y hasta el final. Esto para un programador que le encante programar y piense que “el código es poesía” resulta un tema importante. La programación en Velneo tampoco me resulta muy elegante que digamos pero su sintaxis se acerca más al lenguaje C (con una sintaxis que en mi opinión es muy buena) y sobretodo aún siendo poco estética, resulta igual de fácil de aprender y es una parte más del entorno de desarrollo, nada más. En VB todo es código, por lo que su infumable sintaxis se puede volver un problema. En Velneo, si llevas un desarrollo correcto, rara vez tendrás que escribir una línea de código (a menos que se necesiten hacer tareas críticas o temas muy personalizados que se escapen un poco de la finalidad de Velneo) por lo que no supone un problema tener que utilizar un lenguaje que de primeras no te pueda gustar: es fácil y es en muchos casos auxiliar, en Velneo casi todo está ya programado.

La escalabilidad en un sistema hecho con VB y Access (la base de datos que normalmente se emplea en desarrollos con VB) es muy inferior a la que se puede obtener con una solución Velneo. Y si no, que se lo pregunten a los que hoy día mantienen bases de datos enormes en Velneo, del por qué decidieron migrar…

En VB no se ha sabido llevar un buen y ordenado control de muchas cosas. Por ejemplo, para acceder a ficheros uno tiene muchas formas de hacerlo y esto no siempre es positivo porque no siempre sabes cómo será mejor, si con X función o con Y objeto. Digamos que VB ha crecido en algunas partes del lenguaje de un modo un tanto caótico y a la hora de consultar referencias o ayudas, te encuentras con que puedes solucionar tu problema de varias formas pero no lo tienes claro, no ves cuál es más apropiada o cuál más eficiente para tu caso. Con Velneo hay menos trampas donde poder meter la pata, te puedes preocupar más en las tareas de análisis y diseño del sistema y dejarte de empanadas mentales de ver si es mejor utilizar esta función o usar este otro procedimiento.

A la hora de actualizar una versión de un software hecho con Velneo, podrás estar bastante seguro de que el margen a errores será muy muy pequeño en comparación a actualizar una aplicación hecha con VB. En Velneo no digo que no haya que tener un poco de cuidao cuando se renombren tablas, campos de tablas o cosas así pero el tiempo y preocupaciones que uno se ahorra trabajando con Velneo es muy a tener en cuenta comparado con lo que a uno se le puede venir encima en otros entonos.

El desarrollo de software es un mundo en el que se intenta reducir costes de producción intentando hacer que los tiempos de programación sean cada vez menores. ¿Con Visual Basic se consigue esto en realidad? Comparado con Velneo me temo que no, ya que Velneo sí te permite centrarte de lleno en la construcción de una base de datos sólida y eficiente, sin preocuparte demasiado en los tiempos de pogramación pues ésta es asistida de verdad y uno no tiene que “picar demasiado”.

Información adicional sobre esta anotación:

• Se ha intentado comparar en todo momento algunas de las características de Visual Basic 6 que, a nivel personal, no me terminaron nunca de gustar con algunas características de Velneo.
• Este artículo fue originalmente escrito como material de trabajo para el pasado día 26. Más información en el enlace anterior y en esta otra entrada publicada en la bitácora de Velneo.
• El texto se publicó originalmente en la bitácora de Velneo:
  • En castellano
  • Traducido al inglés

Hace unas semanas me llevaba prestado de la Biblioteca Politécnica de la universidad un pequeño libro acerca de Borland Delphi 6 con la intención de pegarle un rápido repaso a lo fundamental de este entorno de desarrollo. La verdad que las populares guías prácticas de la editorial Anaya Multimedia no gozan de demasiada buena crítica, al menos no las que a mí me llegan. El caso que decidí darle una oportunidad a ésta en concreto puesto que al ver el índice de contenidos y comprobar que me podría valer perfectamente para repasar casi todo lo aprendido este año sobre Delphi 6. Y la conclusión es que no me arrepiento pues fue una lectura amena y al grano, rápida de leer.

El libro está dirigido a lectores sin conocimiento alguno de Delphi. Francamente, si lo único que se quiere tener es una introducción, sin demasiadas explicaciones, para comenzar a hacer tus primeros pinitos no es, entonces, una mala guía. Aunque pienso que siempre y cuando ya te hayas peleado con anterioridad con temas propios de la programación visual y tener una minúscula idea de orientación a objetos. Para partir desde cero y aprender Borland Delphi con bastante solidez recomendaría otro libro: La Cara Oculta de Delphi 4; bastante extenso, me lo he intentado leer casi todo y es incluso divertido a veces gracias a que su autor, Ian Marteens, introduce amenos ejemplos, bromas y comentarios personales :-) Y que no os eche para atrás que el libro se haya escrito para la versión 4 de Delphi, para neófitos de Delphi 6 lo recomendaría incluso _antes_ que su homólogo La Cara Oculta de Delphi 6 (este lo teníamos en clase como material de consulta y, de nuevo, es muy bueno. Aunque, EMHO, no recomendable como libro inicial; más bien, para profundizar en el trabajo con Bases de datos)

El índice de contenidos de la Guía Práctica de Delphi 6 se puede hallar [ aquí ] a continuación, un resumen:

1. Instalación
   1. Introducción
   2. Consideraciones previas
   3. Instalación de Delphi 6
2. El entorno
   1. Introducción
   2. Elementos iniciales
   3. El depósito de objetos
   4. Obtener ayuda
   5. Creación de la interfaz de un programa
3. Gestión de proyectos
   1. Introducción
   2. Gestión de un proyecto
   3. El archivo de proyecto
   4. Archivos de ficha
   5. Módulos de código
   6. Grupos de proyectos
   7. Otros elementos de un proyecto
4. Fundamentos de Object Pascal
   1. Introducción
   2. Estructura general
   3. Constantes y variables
   4. Ámbito de los identificadores
   5. Expresiones
   6. Estructuras de control
   7. Procedimientos y funciones
   8. Fundamentos de orientación a objetos
5. Manipulación de componentes
   1. Introducción
   2. Tipos de componentes
   3. Instalación de un componente
   4. Propiedades
   5. Eventos
   6. Métodos
6. Componentes más habituales
   1. Introducción
   2. Trabajar con la ficha
   3. Botones
   4. Etiquetas de texto
   5. Petición de datos
   6. Entrada de texto
   7. Selección de opciones
   8. Selección de opciones exclusivas
   9. Grupos de opciones exclusivas
   10. Listas de elementos
   11. Listas desplegables
   12. Controles contenedores
   13. Barras de desplazamiento
   14. Elementos gráficos
   15. Imágenes de mapas de bits
   16. Listas de unidades, carpetas y archivos
   17. Eventos periódicos
   18. Construcción y uso de menús
7. Depuración y excepciones
   1. Introducción
   2. Proceso de depuración
   3. Control de excepciones
8. Uso de múltiples ventanas
   1. Introducción
   2. Trabajo con múltiples fichas
   3. Cuadros de diálogo de uso común
   4. En la práctica
9. Trabajo con bases de datos
   1. Introducción
   2. Gestión de alias
   3. Creación de una tabla
   4. Modificar la estructura de una tabla
   5. Editar el contenido de una tabla
   6. Consultas
10. Componentes enlazados a datos
    1. Introducción
    2. Edición de una tabla
    3. Tablas y consultas
    4. Controles enlazados a datos
    5. Acceso programático a los datos
11. Creación de informes
    1. Introducción
    2. Funcionamiento general de QuickReport
    3. El componente TQuickReport
    4. El componente TQRBand
    5. Contenido de las secciones
    6. Un ejemplo
12. Componentes avanzados
    1. Introducción
    2. Valores discretos y rangos
    3. Curso de un proceso
    4. Incrementar y decrementar valores
    5. Cabeceras redimensionables
    6. Barras de estado
    7. Ventanas multipágina
    8. Almacenes de imágenes
    9. Listas jerárquicas
    10. El control TListView
    11. Barras de botones
13. Reutilización del trabajo
    1. Introducción
    2. Listas de acciones
    3. Componentes compuestos

La parte que me he visto por encima es la que trata el conjunto de componentes de uso más común a la hora de diseñar formularios y frames. Aunque no crea que sobra del todo, tampoco pienso que merezca mucho la pena (y mucho menos estudiársela. Para algo están las ayudas en línea). De las que menos me ha gustado es la que explica el trabajo con bases de datos. Sólo se centra en el, hoy por hoy obsoleto, BDE y el manejo del Database Desktop (una versión reducida de Paradox –enlazo a la Wikipedia porque esto debería ya tener mero carácter enciclopédico jeje–). Creo que habría estado más acertado mostrar InterBase como gestor de bases de datos y explicar los componentes IBX como controles de acceso a datos. La sección que le dedican a la programación orientada a objetos es, a lo sumo, anecdótica (creo recordar –ya no tengo el libro– que le dedicaban ¿un par de hojas?).

Partes que recuerdo me hayan gustado más han sido las del tratamiento de excepciones (bastante resumida), la gestión de proyectos Delphi o la dedicaba al uso de múltiples ventanas. También la de creación de informes creo recordar que me pareció interesante (aunque, también, algo desfasado el QReports).

En resumen, para repasar en momentos REDOX (aquellos que se viven sin tocar para nada el entorno y empiezas a oxidarte) me parece una rápida y concisa referencia. No está mal.

Título: Delphi 6 (Guias Practicas)
Autor: Francisco Charte Ojeda
ISBN: 84-415-1255-8
Precio: 12,30 €
Edición: Anaya Multimedia
Impreso en España.

Una forja de software se podría definir como un punto de encuentro preparado para albergar un extenso y variado grupo de proyectos software. Dicho de otro modo, sería un repositorio de código fuente. Creo que todas estas forjas son accesibles a través de la web y, además de servir de repositorio de código, ofrecen una serie de servicios y herramientas para llevar a cabo el desarrollo de cada proyecto. SourceForge.net está desarrollada con un software del mismo nombre y aporta útiles herramientas: diversos sistemas de seguimiento (de bugs, de solicitudes y de parches), foros, listas de correo y repositorio CVS accesible por web. Bueno, y más cosas como servicio de alojamiento web, centro de descargas de cada proyecto albergado, descripciones e información de los mismos, posibilidad de unirse a otros proyectos y participar en ellos, información de desarrolladores, tablones de noticias… y un largo etcétera pues es un sitio muy muy amplio. Tiene de todo para llevar a buen puerto desarrollos de software en equipo, del modo más ágil y efectivo que se pueda.

Dicho esto, esta tarde he registrado lo que será el primer proyecto que quiero poner en marcha en SourceForge.net. Bueno, no es así del todo porque para que llegue a convertirse en un nuevo proyecto de esta forja, la propuesta del mismo que he enviado debe ser aceptada. Por lo que hasta el momento todavía está pendiente de ser revisado por el equipo humano de SF.net. [act: acabo de mirar y el proyecto ya ha sido aprobado, ¡Mola!]

Project Registration: Submission completed

Your request should be reviewed by SourceForge.net staff in the next two business days (9AM to 5PM, Monday through Friday). Response regarding your project (notice of rejection/approval) will be posted to your My SourceForge.net Projects page (accessible via the My SF.net link at the top of each site page). No email notification will be provided about approval/rejection of your project.

For your convenience, a copy of the details you submitted about your project has been sent to you via email. Please keep this information in a safe place, for future reference.

Should you have questions or concerns regarding the status of your project registration, please submit a Support Request.

You may check on the status of your project at any time using the My SF.net Projects page. Until your registration is reviewed by SourceForge.net staff, it will be shown in the list of Pending Projects on the My SF.net Projects page. After review has occurred, it will appear in the list of Active or Rejected projects, depending on the outcome of that review.

SourceForge.net: Project Registration.

Y poco más que comentar hasta el momento. El objetivo con esto es reescribir por completo una aplicación de gestión de informes que en su día le hice a mi madre para su trabajo y hacerlo progresivamente a través de SF.net donde, finalmente, quedará liberada con una licencia GPL. Por supuesto ya tengo el problema descrito y analizado, esquemas EER, diagramas de flujo de datos, diseños de la GUI, entradas, salidas y rollos varios. Para la, posible, sorpresa de algunos, el resultado será un aplicativo que corra sobre Microsoft Windows’ que son las plataformas donde, se supone, funcionará. Del gestor de bases de datos todavía estoy decidiéndolo. Y el entorno de desarrollo elegido es Borland Delphi 6 que hoy día es una plataforma de desarrollo antigua y seguro que no la mejor opción para desarrollar, pero que en fin, para mí es suficiente y además es lo que me enseñan en clase. Este programa servirá como proyecto de fin de curso de una de mis asignaturas, así que ello mucho tiene que ver para que lo vaya a hacer en este entorno…

Como todavía no tengo más que vaporware y me ha hecho mucha ilusión la tontada de registrar un proyecto en SF.net pues por eso de escribir una nota así, sin dar grandes detalles. Si a medida que vaya terminando consigo algo loable de ser reseñado aquí, toma ya, de seguro escribiré más al respecto.

Para terminar, recomendar a los navegantes el darse una vuelta por SourceForge.net porque seguro encuentran algo de mucha utilidad :-)

Se trata de The Evolution of a Programmer, un elocuente manifiesto en clave de humor que refleja el ciclo de vida de todo buen programador que se precie. Desde los más dulces inicios en tiempos de instituto y acné facial, enamorado del Spectrum y BASIC, hasta la decadencia del propio ser en el lado oscuro de la fuerza ;-) Cuando lo leáis, entenderéis mejor de lo qué estoy hablando jaja.

Aunque el texto apareció publicado originalmente en la página web de Iavor S. Diatchki, está firmado de forma anónima, por lo que a priori se desconoce el autor del mismo.

No revelo más, espero que disfruten del genuino (y sano, aunque no lo parezca :P) humor informático. Con todos ustedes, las etapas del un programador:

High School/Jr.High

10 PRINT "HELLO WORLD"
20 END

First year in College

program Hello(input, output)
  begin
    writeln('Hello World')
  end.

Senior year in College

(defun hello
  (print
    (cons 'Hello (list 'World))))

New professional

#include <stdio.h>
void main(void)
{
  char *message[] = {"Hello ", "World"};
  int i;
 
  for(i = 0; i < 2; ++i)
    printf("%s", message[i]);
  printf("\n");
}

Seasoned professional

#include <iostream.h>
#include <string.h>
 
class string
{
private:
  int size;
  char *ptr;
 
  string() : size(0), ptr(new char[1]) { ptr[0] = 0; }
 
  string(const string &s) : size(s.size)
  {
    ptr = new char[size + 1];
    strcpy(ptr, s.ptr);
  }
 
  ~string()
  {
    delete [] ptr;
  }
 
  friend ostream &operator <<(ostream &, const string &);
  string &operator=(const char *);
};
 
ostream &operator<<(ostream &stream, const string &s)
{
  return(stream << s.ptr);
}
 
string &string::operator=(const char *chrs)
{
  if (this != &chrs)
  {
    delete [] ptr;
    size = strlen(chrs);
    ptr = new char[size + 1];
    strcpy(ptr, chrs);
  }
  return(*this);
}
 
int main()
{
  string str;
 
  str = "Hello World";
  cout << str << endl;
 
  return(0);
}

Master Programmer

[
uuid(2573F8F4-CFEE-101A-9A9F-00AA00342820)
]
library LHello
{
    // bring in the master library
    importlib("actimp.tlb");
    importlib("actexp.tlb");
 
    // bring in my interfaces
    #include "pshlo.idl"
 
    [
    uuid(2573F8F5-CFEE-101A-9A9F-00AA00342820)
    ]
    cotype THello
 {
 interface IHello;
 interface IPersistFile;
 };
};
 
[
exe,
uuid(2573F890-CFEE-101A-9A9F-00AA00342820)
]
module CHelloLib
{
 
    // some code related header files
    importheader(<windows.h>);
    importheader(<ole2.h>);
    importheader(<except.hxx>);
    importheader("pshlo.h");
    importheader("shlo.hxx");
    importheader("mycls.hxx");
 
    // needed typelibs
    importlib("actimp.tlb");
    importlib("actexp.tlb");
    importlib("thlo.tlb");
 
    [
    uuid(2573F891-CFEE-101A-9A9F-00AA00342820),
    aggregatable
    ]
    coclass CHello
 {
 cotype THello;
 };
};
 
#include "ipfix.hxx"
 
extern HANDLE hEvent;
 
class CHello : public CHelloBase
{
public:
    IPFIX(CLSID_CHello);
 
    CHello(IUnknown *pUnk);
    ~CHello();
 
    HRESULT  __stdcall PrintSz(LPWSTR pwszString);
 
private:
    static int cObjRef;
};
 
#include <windows.h>
#include <ole2.h>
#include <stdio.h>
#include <stdlib.h>
#include "thlo.h"
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"
 
int CHello::cObjRef = 0;
 
CHello::CHello(IUnknown *pUnk) : CHelloBase(pUnk)
{
    cObjRef++;
    return;
}
 
HRESULT  __stdcall  CHello::PrintSz(LPWSTR pwszString)
{
    printf("%ws", pwszString);
    return(ResultFromScode(S_OK));
}
 
CHello::~CHello(void)
{
  // when the object count goes to zero, stop the server
  cObjRef--;
  if( cObjRef == 0 )
    PulseEvent(hEvent);
 
  return;
}
 
#include <windows.h>
#include <ole2.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "mycls.hxx"
 
HANDLE hEvent;
 
int _cdecl main(
int argc,
char * argv[]
) {
ULONG ulRef;
DWORD dwRegistration;
CHelloCF *pCF = new CHelloCF();
 
hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
// Initialize the OLE libraries
CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
CoRegisterClassObject(CLSID_CHello, pCF, CLSCTX_LOCAL_SERVER,
    REGCLS_MULTIPLEUSE, &dwRegistration);
 
// wait on an event to stop
WaitForSingleObject(hEvent, INFINITE);
 
// revoke and release the class object
CoRevokeClassObject(dwRegistration);
ulRef = pCF->Release();
 
// Tell OLE we are going away.
CoUninitialize();
 
return(0); }
 
extern CLSID CLSID_CHello;
extern UUID LIBID_CHelloLib;
 
CLSID CLSID_CHello = { /* 2573F891-CFEE-101A-9A9F-00AA00342820 */
    0x2573F891,
    0xCFEE,
    0x101A,
    { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};
 
UUID LIBID_CHelloLib = { /* 2573F890-CFEE-101A-9A9F-00AA00342820 */
    0x2573F890,
    0xCFEE,
    0x101A,
    { 0x9A, 0x9F, 0x00, 0xAA, 0x00, 0x34, 0x28, 0x20 }
};
 
#include <windows.h>
#include <ole2.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "pshlo.h"
#include "shlo.hxx"
#include "clsid.h"
 
int _cdecl main(
int argc,
char * argv[]
) {
HRESULT  hRslt;
IHello        *pHello;
ULONG  ulCnt;
IMoniker * pmk;
WCHAR  wcsT[_MAX_PATH];
WCHAR  wcsPath[2 * _MAX_PATH];
 
// get object path
wcsPath[0] = '\0';
wcsT[0] = '\0';
if( argc > 1) {
    mbstowcs(wcsPath, argv[1], strlen(argv[1]) + 1);
    wcsupr(wcsPath);
    }
else {
    fprintf(stderr, "Object path must be specified\n");
    return(1);
    }
 
// get print string
if(argc > 2)
    mbstowcs(wcsT, argv[2], strlen(argv[2]) + 1);
else
    wcscpy(wcsT, L"Hello World");
 
printf("Linking to object %ws\n", wcsPath);
printf("Text String %ws\n", wcsT);
 
// Initialize the OLE libraries
hRslt = CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
if(SUCCEEDED(hRslt)) {
  hRslt = CreateFileMoniker(wcsPath, &pmk);
  if(SUCCEEDED(hRslt))
    hRslt = BindMoniker(pmk, 0, IID_IHello, (void **)&pHello);
 
  if(SUCCEEDED(hRslt)) {
    // print a string out
    pHello->PrintSz(wcsT);
 
    Sleep(2000);
    ulCnt = pHello->Release();
  }
  else
    printf("Failure to connect, status: %lx", hRslt);
 
  // Tell OLE we are going away.
  CoUninitialize();
}
 
return(0);
}

Apprentice Hacker

#!/usr/local/bin/perl
$msg="Hello, world.\n";
if ($#ARGV >= 0) {
  while(defined($arg=shift(@ARGV))) {
    $outfilename = $arg;
    open(FILE, ">" . $outfilename) || die "Can't write $arg: $!\n";
    print (FILE $msg);
    close(FILE) || die "Can't close $arg: $!\n";
  }
} else {
  print ($msg);
}
1;

Experienced Hacker

#include <stdio.h>
#define S "Hello, World\n"
main(){exit(printf(S) == strlen(S) ? 0 : 1);}

Seasoned Hacker

% cc -o a.out ~/src/misc/hw/hw.c
% a.out

Guru Hacker

% echo "Hello, world."

New Manager

10 PRINT "HELLO WORLD"
20 END

Middle Manager

mail -s "Hello, world." bob@b12
Bob, could you please write me a program that prints "Hello, world."?
I need it by tomorrow.
^D

Senior Manager

% zmail jim
I need a "Hello, world." program by this afternoon.

Chief Executive

% letter
letter: Command not found.
% mail
To: ^X ^F ^C
% help mail
help: Command not found.
% damn!
!: Event unrecognized
% logout

Impresionante ¿eh? Yo me quedo con la última etapa, es genial :-D Y además de una gran verdad; en el momento que dejas de practicar, comienza tu proceso de oxidación (y, éste, tiene límites insospechados como se puede observar jajaja). Y la cosa no queda aquí, para quien quiera más dosis que no se pierda la sección de jokes, chistes, de Iavor.

Y para terminar, también os dejo con The Evolution of a Haskell Programmer, un enlace a un texto en la misma línea pero enfocado a programadores de Haskell y bastante más trabajado por cierto.

Anotaciones relacionadas:

• ¡El código fuente de Windows publicado!
• The Hello World Collection

A través de DiarioLinux.com y Barrapunto encuentro un fantástico recurso en castellano sobre desarrollo de aplicaciones GNOME basadas en librerías como GLib o GTK+.

La escasez de una documentación en castellano lo suficientemente sólida tanto para desarrolladores en el entorno GNOME como para principiantes impulsó a varias personas de GNOME Hispano a iniciar la elaboración de un libro que reuniera los conceptos necesarios para enseñar la programación de aplicaciones en este entorno. Los objetivos son ofrecer una documentación accesible para todo el mundo y actualizada, por ello es que el libro está publicado con licencia GFDL y se encuentra en su, recientemente lanzada, versión 0.0.3.

Programación en el entorno GNOME se encuentra disponible en su página web, en tres formatos:

• Versión en HTML (ver en línea)
• Versión en PDF
• Versión en HTML comprimido (TGZ)

Para mayor información, se recomienda echar un vistazo a la web del libro. Desde aquí felicitar y agradecer el trabajo desinteresado de toda la gente que, de cualquier modo, está detrás de este recurso.

Vía Microsiervos y Pau Iglesias doy con CFDG, una especie de lenguaje de programación para obtener, de un modo rápido y bastante sencillo, formas geométricas renderizadas. Las posibilidades son realmente infinitas ya que las imágenes que pueden llegar a obtenerse se limitan a la capacidad creativa de cada uno. Además, la figura obtenida puede llegar a ser de hasta 1 Gigapixel.

El lenguaje fue ideado por Chris Coyne y, a groso modo, la codificación consiste en tres aspectos principales:

1. Inclusión de una directiva

   startshape

   con la que dar un nombre lógico al código de tu figura (Para los que conozcáis Pascal, podría decirse que es algo así como la directiva

   PROGRAM

   en éste lenguaje)
2. Utilización de “bloques”

   rule

   . Estos fragmentos de código,

   rule { }

   son los que contienen las características de cada elemento que forme el resultado final. Se le podría asemejar, de algún primitivo modo, al concepto de funciones en lenguajes de programación estructurados; de este modo, podríamos decir que debe haber al menos una función, principal, que tenga el mismo identificador que el usado para definir a

   startshape

   . Podríamos decir que éste sería el “constructor” de nuestra clase (figura).
3. El círculo y el cuadrado: nuestros dos objetos predefinidos; elementos con los que nos valdremos para realizar nuestras figuras. Aunque estos sean los elementos básicos, es posible conformar otras formas geométricas, por ejemplo hexágonos u octógonos. CFDG tiene una sentencia

   include

   con la que poder incluir los bloques

   rule {}

   de otros ficheros; por lo que sería posible crearse librerías de formas poligonales (o lo que deseemos) para utilizar como “elementos básicos” en nuestros diseños finales.

A la hora de trabajar con este curioso lenguaje, tenemos disponible y de manera libre Context Free, la herramienta con la que escribir el código y renderizarlo “al vuelo”, con la posibilidad de guardarlo y de generar imágenes en formato PNG. Las características que ofrece son:

• Binarios multiplataforma para Macintosh, Windows y Posix/Unix.
• Actualización progresiva en la generación de las imágenes.
• Posibilidad de guardar los resultados en formato PNG.
• Renderizar imagenes de gran tamaño (hasta 100 Megapixeles).
• Posibilidad de manejar imágenes generadas con infinidad de formas.
• La aplicación viene con ejemplos didácticos de uso (realmente se podría decir que son el manual de usuario.
• etc.

Como punto débil le veo la prácticamente nula documentación acerca del aprendizaje del lenguaje. Para los interesados en el uso de Context Free podéis echar un vistazo en:

• Acerca de Context Free. Un buen punto inicial para comenzar a aprender sobre en qué consiste esta herramienta y cómo empezar a dar los primeros pasos.
• Galería de ejemplos. Además de ser realmente impresionante, cada ejemplo puede ser útil para aprender ya que se le han adjuntado su correspondiente fichero fuente.
• Foro y soporte. De lo mejorcito de la página, existen unos cuantos foros (incluso uno para hispanohablantes :)) donde obtener mucha información, más ejemplos y donde preguntar dudas.
• Página de descarga

He estado jugando un rato con esto, aunque no creo que lo vaya a utilizar mucho más, y he llegado a crear “algo” :-) Bueno, inicialmente he intentado hacer una estructura en forma de “cromosoma” y utilizando para ello, digamos, dos “bandas de ADN” formadas por un par de cromosomas para cada una. No sé si me explico… en fin, la cuestión es que a medida que iba trasteando me ha ido saliendo otra forma distinta a la pensada inicialmente. Y como me ha gustado lo que me iba saliendo, he seguido hasta llegar a esto:

Resultado

Código

startshape undefImg

/*
 * "programa" principal *
                        */

rule undefImg
{
	struct_a { } // espiral concava
	struct_b { } // espiral convexa

	debianize    // cabeza espiral
	{
		x 56 // coordenada eje x
		y 70 // coordenada eje y
	}
}

/*
 * parte superior de la imagen *
                               */

rule struct_a
{
	concavo_1 { }
	concavo_2 { }
	convexo_1 { }
}

/*
 * parte inferior de la imagen *
                               */
rule struct_b
{
	linea { }
	SQUARE { x 35 y 35 s 2 b .2 }
}

/*
 * parte individual superior derecha *
                                     */
rule debianize
{
	CIRCLE { b .2 }
	debianize { x 2 s 0.99 r -10 }
}

/*
 * la "magia potagia" (viva el ensayo-error) *
                                             */

rule concavo_1
{
	CIRCLE { b .2 }
	concavo_1 { x 2 s 0.99 r 2 }
}

rule convexo_1
{
	SQUARE { b .1 }
	convexo_1 { y 2 s 0.99 r -2 }
}

rule concavo_2
{
	SQUARE { b .1 }
	concavo_1 { x -2 s .99 r -2 }
}

rule linea
{
	SQUARE { b .2 }
	linea { x .5 y .5 s .99 }
}

Inicialmente obtuve las formas en espiral cóncava y convexa en sus aberturas. Iba a dejarlo así y llamar a la creación “Trompas de Falopio” (cromosomas, trompas de falopio… bueno, algo tienen en común ¿no? XD). Luego pensé que ya que estaba, seguía y terminaba la obra de arte es una especie de tijeras utilizando para ello una línea que dividiera en dos partes simétricas mi anterior forma. Bueno, y lo de esa espiral suelta que aparece por arriba… ni idea, para rellenar más supongo. Al final no ha quedado tan mal, eso sin tener más que cuatro conceptos de la sintaxis que emplea el lenguaje, investigando unos cuantos ejemplos y poco más. Con más dedicación no es difícil conseguir aprender a crear verdaderas virguerías gráficas.

Para terminar, os recomiendo visitar las imágenes contenidas en Flickr bajo la etiqueta contextfree. Se pueden ver ejemplos muy curiosos.

El pasado 31 de mayo salía públicamente a la luz Versión Cero, una prometedora bitácora colectiva enfocada a la publicación de noticias y artículos sobre el mundo del desarrollo de software. La iniciativa viene de la mano de Juanjo Navarro, acompañado por un pequeño grupo de personas forofas de la programación, con amplios conocimientos y tiempo suficiente para mantener una buena relación calidad / cantidad de anotaciones.

Quizás, a día de hoy, prácticamente la totalidad de los lectores asiduos a esta bitácora ya conocierais la existencia de esta bitácora. De todos modos, no he podido resistir la ocasión de anotar una referencia a la misma ya que quería tenerla en mi historial de archivos.

Aunque actualmente cuente sólo con poco más de un mes de vida, el ritmo de publicación es realmente bueno y ya es posible visitar alrededor de doscientas anotaciones. El contenido de Versión Cero, aunque centrado en aspectos de programación y afines, es muy polivalente. Como en su misma página de información comenta, se intenta que el contenido de la bitácora no esté atada a tecnologías, plataformas, metodologías ni, incluso, filosofías de ningún tipo; con el fin de ofrecer un sitio abierto, capaz de informar al mayor número de personas.

Los contenidos de Versión Cero se distribuyen bajo una licencia Creative Commons con la que se reservan algunos derechos. En esta página se esclarecen las condiciones de uso, copia y distribución.

Un sitio muy recomendable para cualquier interesado en el mundo de la programación y desarrollo de software. Personalmente me parece de mucha utilidad la sección de artículos que se mantiene. En la actualidad ya hay cinco disponibles y, a mi juicio, es la sección más prometedora. Con concisos escritos, los autores de Versión Cero nos muestran su punto de vista acerca de aspectos que preocupan e interesan a cualquier desarrollador o estudiante; además la sección de comentarios en esta sección está funcionando francamente bien, pudiendo leer otros puntos de vista que hasta el momento no hacen más que enriquecer cada artículo.

Desde aquí, agradecer el esfuerzo que están realizando los editores de la criatura y animarles a que continúen igual de bien que hasta ahora. Poco a poco aparecen más y más sitios en castellano dedicados exclusivamente a la programación o el desarrollo de software; así que ya no hay excusa para no estar informado de lo que se cuece en este apasionante mundo :-)

Enlace: http://www.versioncero.com/

Esta vez, a través de Microsiervos, doy con una página web que recopila un gran puñado de ejemplos (190) para el popular programa “Hello World” (o también Hola Mundo) implementado en infinidad de lenguajes de programación.

Este suele ser el primer programa que uno es capaz de escribir cuando comienza a aprender un nuevo lenguaje de programación. Desde siempre, que yo sepa, se ha venido utilizando este ejercicio de programación como uno de los primeros, por no decir el primero, para mostrar en las primeras páginas de los libros introductorios a un lenguaje de programación. No todos los libros o textos al respecto recurren a este tradicional programa pero sí la mayoría y pienso que precisamente por eso: por tradición :-)

Como nota anecdótica / personal, creo haber escrito un “Hola Mundo” en al menos ASP, C, C++, Delphi, Java, JavaScript, Pascal, Perl, PHP, Prolog, Tcl y Visual Basic 6 (que recuerde ahora). De la mayoría tengo al menos un libro y ojalá pudiera decir que sé y he aprendido a programar en todos ellos, cosa que obviamente no es así :-) ¿Cuántos “hola mundo” lleváis a vuestras espaldas?

Enlace: http://www.roesler-ac.de/wolfram/hello.htm

1. PEREZA: La cualidad que te hace esforzarte para reducir el gasto de energía total. Te hace escribir programas de ayuda al trabajo que otros encontrarán útiles, y documentar lo que escribiste para no tener que responder a preguntas sobre ello. Esta es la primera gran virtud de un programador.
2. IMPACIENCIA: La cólera que sientes cuando el ordenador está holgazaneando. Te hace escribir programas que no solo reaccionan a tus necesidades, si no que se anticipan a ellas. O al menos que simulan hacerlo. Esta es la segunda gran virtud de un programador.
3. ORGULLO DESMEDIDO: Orgullo excesivo, el tipo de actitud por la que Zeus te fulminaría. También, la cualidad que te hace escribir (y mantener) programas que nadie querrá criticar. Esta es la tercera gran virtud de un programador.

He constatado que soy poseedor de al menos el primer par de ellas. Lo malo es que no consigo hacer lo suficiente como para poder hacer de ellas eso mismo: virtudes :-)

El sitio se llama ConnectionStrings.com y su intención no es otra que recopilar el mayor número de cadenas de conexión para conectar con cualquier base de datos, 23 en concreto (SQL Server, Access, Oracle, MySQL, Interbase, IBM DB2, Sybase, Informix, Ingres, Mimer SQL, Lightbase, PostgreSQL, Paradox, …) además mediante OLE DB o su antecesor ODBC.

Un listado completo ideal para quienes necesiten conectar con diferentes bases de datos con frecuencia a la hora de programar y también para quien no tenga ganas de aprender estos chorizos infumables que son las connection strings. Más vale dedicar las neuronas en aprender / memorizar otras cosas y utilizar esta lista a modo de chuleta o “tarjeta de referencia en línea” :-)

Enlace: http://www.connectionstrings.com