Primeros Pasos en BBj
Este documento busca introducirnos en la forma de programación que incluye ahora BBj. Muchos de los lectores estarán familiarizados con BBx, Pro5 y Visual Pro5, y cada uno tendrá desafíos distintos para aprender BBj.
Si programas en BBx desde siempre, te resultará mucho más fácil dar el salto a BBj que hacerlo desde Visual Pro/5. Si ya desarrollas en Vpro5 probablemente te costará menos comprender la modalidad orientada a eventos de BBj, pero tendrás el desafío de comprender la sintaxis de objetos para manipular el GUI en lugar de recurrir a los PRINT con mnemónicos para producir tus efectos en el GUI.
Si programas en Visual Pro5 usando Resbuilder para crear tus formularios, y creas un programa para manipularlo desde cero, verás que no hay mayores cambios respecto a tu programación actual para migrar a BBj.
Sin embargo, en una muy humilde recomendación, te sugiero sacar de tu mente todo lo que ya conoces para iniciar la comprensión de una nueva y mucho más moderna modalidad de programación, que incluso te permitirá comprender otros lenguajes orientados a objetos.
Mucho se habla de la POO (programación orientada a objetos) como una excelente y estructurada herramienta de programación. Para los que venimos del “Mundo bbx” esto puede resultar un cambio dramático en nuestra forma de hacer las cosas. Eso asusta, y quizás en eso radique la dificultad que ha tenido la comunidad para cambiar el switch y pasar a aprovechar todo lo nuevo que incorpora BBj. Para nuestro consuelo, es lo mismo que ha ocurrido con los cambios que han experimentado otros lenguajes de programación. Tal vez concuerden conmigo, en que los programador de Microsoft Visual Basic 6, han tenido un férrea resistencia para pasar a Visual Basic .Net, aún con toda la maquinaria que mueve Microsoft para promocionar sus productos.
BASIS es mucho menos que Microsoft en cuanto a tamaño, por lo que era de esperar que su manera de abordar la capacitación de los desarrolladores en su lenguaje tuviera sus limitaciones.
Por mucho tiempo BASIS no realizó un gran despliegue en capacitación. Recién hace un par de años hemos comenzado a ver un esfuerzo más completo por entregar los conocimientos requeridos para migrar a BBj. Sin embargo, el mundo hispano ha visto más limitados aún su oportunidad de capacitarse, pues gran parte de la información disponible (por no decir, toda) está en inglés. Hemos tenido algunos debates de palabras con colegas de distintos países sobre el efecto que esto pudiera tener en el aprendizaje del lenguaje. Algunos dicen que no es impedimento para aprender (yo concuerdo con esa opinión); pero muchos agradecen cualquier esfuerzo que se haga por acercar BBj y en general los productos BASIS a aquellos que se encuentran limitados por el idioma.
Basta pensar que los potenciales “nuevos” desarrolladores en BBj principalmente salen de la cantera BBx, y no muchos vienen de otros lenguajes (muchos preferirán aprender Java o .NET, en lugar de un lenguaje cuyo mercado se encuentra tan acotado y es tan pequeño). Por eso, que mejor que de entre nosotros mismos, surja el apoyo que necesitamos para pasarnos a BBj, darle nueva fuerza al mundo BBx y más ahora que contamos con una herramienta que tiene muy poco que envidiar a los lenguajes más de moda existentes hoy.
Mi invitación es a que juntos hagamos el esfuerzo. Piensa por un momento cuántas aplicaciones hay desarrolladas en BBx circulando por ahí. Cuanta experiencia acumulada a través de los años, traducida en sistemas robustos que pueden seguir reportando beneficios económicos para nosotros. Por que perder eso, por tener que mirar a otros lenguajes para responder a las peticiones de “modernizar” los sistemas de las empresas en que trabajamos, o de los clientes a los cuales les prestamos servicios.
Mientras más crezca el mercado BBj por el aumento que podamos hacer en la distribución de aplicaciones BBj, podremos asegurar nuestra continuidad laboral, la supervivencia de nuestros sistemas y el crecimiento de un lenguaje que está sabiendo adaptarse a los nuevos tiempos.
Este tutorial abordará principalmente una de las formas en que podemos comenzar a programar en BBj. En mi muy humilde opinión basada en la experiencia adquirida al trabajar con BBj he concluido que una de las mejores formas de trabajar BBj es construyendo todo a partir de código, incluyendo la creación de formularios GUI (Graphic User Interface, por sus siglas en inglés). Esto porque nos permite tener programas más dúctiles e interesantes. Además, si siempre hemos programado en BBx, nos será más fácil comprender los nuevos conceptos.
Por último, considero oportuno comentar que en este tutorial no entraremos en la POO en el sentido pleno de la palabra (lo cual incluye la creación de programas con clases, métodos y los demás conceptos propios de la POO). Partiremos solo haciendo programas que “usan” la sintaxis de objetos. Y esto es muy oportuno, pues dar un salto directo a la POO es derechamente lejano a las ambiciones de la presente ayuda.
LA API de BBj
Es muy importante comprender como empezaremos a usar la sintaxis de objetos en BBj. Al entender bien este concepto desde el comienzo, nos servirá muchísimo para adentrarnos en el conocimiento de los incontables elementos de BBj bajo la sintaxis de objetos.
Partamos con algo de teoría. ¿Qué debemos entender por objetos cuando hablamos de la POO?
Los manuales de POO definen un objeto como un componente de software que encapsula estado y un comportamiento. Los objetos permiten dar forma al software en términos y abstracciones reales. En términos estrictos, un objeto es una instancia de una clase.
Pero, ¿qué es una clase? Al igual que los objetos en la vida real, el mundo de la POO agrupa los objetos de acuerdo con sus comportamientos y atributos comunes. Tomemos un ejemplo de biología: los perros, gatos, elefantes y humanos se clasifican como mamíferos, porque tienen características comunes aunque estamos hablando de especies distintas. De la misma forma, en el mundo del software, las clases agrupan a todos aquellos objetos que tienen alguna relación. Por lo tanto, debemos entender que una clase define los atributos y comportamientos comunes que comparte un tipo de objeto. Los objetos de un tipo dado comparten los mismos comportamientos y atributos (luego comentaremos que se entiende por comportamiento y que se entiende por atributo).
Las clases actúan muy parecido a un molde para galletas, en el sentido que una clase se utiliza para crear o “instanciar” un objeto; tal como un molde se usa para crear galletas.
Los atributos son las características externas y visibles de una clase.
Un comportamiento es la acción que realiza un objeto cuando se le pasa información.
Dichas estas definiciones, comencemos a entender el trabajo en BBj.
Recurriendo al paradigma de la POO, BASIS definió a BBj como un conjunto de clases que los desarrolladores podemos utilizar. Esto nos lleva a la necesidad de entender el lenguaje de una manera distinta. Si antes veíamos a BBx y Vpro5 como un lenguaje con un conjunto de comandos, funciones, variables y mnemónicos que podemos utilizar, ahora podemos ver a BBj como un conjunto de piezas base que podemos utilizar para armar nuestras aplicaciones (tenemos los moldes para hacer galletas de las más variadas figuras).
Por lo tanto, tenemos que aprender a “instanciar” o crear los objetos que iremos necesitando a partir de las clases base existentes en BBj.
Con el fin de facilitarnos el aprendizaje y el uso de estas clases, BBj presenta mucha de la funcionalidad disponible en una estructura de árbol en la que podemos ir adentrándonos conforme van surgiendo las necesidades. Conviene aclarar que la forma de programar que conocemos de BBx y Vpro5 se conserva casi en un 100%. La virtud de los nuevos conceptos es que podemos lograr exactamente la misma funcionalidad pero recurriendo a la sintaxis de objetos. Es más, hasta podemos trabajar combinados elementos de la vieja escuela con elementos de la nueva. Quizás esa sea la tónica en tus primeros programas en BBj, pues donde falte el conocimiento de cómo hacer algo en sintaxis de objetos, te servirá de salvavidas utilizar la modalidad de programación a la que estas habituado actualmente.
El objeto BBjAPI es el punto de entrada para crear y usar objetos BBj. Si queremos comenzar a desarrollar programas con sintaxis de objetos, esto será lo primero que veremos en todo programa BBj. Bajo el BBjAPI se encuentran alistados los principales objetos de BBj. Estos son:
BBjAPI
BBjAdmin
BBjConfig
BBjFileSystem
BBjPrinter
BBjRecordSet
BBjSysGui
BBjMDI
BBjThinClient
¿Cómo accedemos al BBjAPI?
Para comenzar a usarlo, debemos aplicar uno de los conceptos de objetos antes comentado en este tutorial: “instanciar” la clase BBjAPI en nuestro programa. Es decir, sacamos un molde del BBjAPI y a partir de ese punto nuestro programa comenzará a interactuar con la copia, no con el molde. Y para hacernos sencillo el concepto, BBj permite hacer esto mediante una simple asignación a una variable, tal como cuando decimos A$=”hola” en un programa, con una pequeña diferencia, y es que ahora contamos con un nuevo tipo de variables en BBj, las variables objetos, que se diferencian de las otras, porque terminan con un signo de exclamación. Por ejemplo: A!.
Pero, quizás te preguntarás en este punto, ¿dónde comienzo a escribir código en BBj? Esta pregunta tiene varias respuestas, algunas requieren más detalle que otras, pero digamos que hoy con BBj, se puede escribir un programa en el bloc de notas o en Wordpad de Windows, con vi en Unix/Linux, en la “pantalla negra” de BBj o en el BASIS IDE incluido en BBj. Pero para demostrar la fácil de programar con BBj, hagamos una carpeta en nuestro disco duro con un nombre de nuestro agrado y dentro de esa carpeta creemos un documento de texto en blanco con el bloc de notas. También ejecutemos BBj con la ventana negra para luego llamar nuestro programa, ya sea usando la ruta completa de la carpeta que acabamos de crear o si deseamos agregar en el PREFIX la carpeta para luego llamarlo directamente.
Sí, estás leyendo bien, podemos escribir el código en el bloc de notas y luego en BBj llamar ese programa. Y no necesitaremos hacer una conversión a BBj del texto, porque BBj ahora interpreta los programas sin conversión (el único cuidado al hacerlo en el bloc de notas, es que este automáticamente le asigna extensión .txt al archivo, por lo que luego debemos llamarlo con la extensión asignada o si deseamos cambiarla hacerlo antes de llamar el programa en BBj).
El siguiente código “instancia” el BBjAPI en nuestro programa (llamaremos a nuestro programa PRG01):
rem "[PRG01] Mi Primer Programa en BBj
rem
rem "Obtiene una instancia del objeto BBjAPI
rem "=======================================
LET miAPI!=BBjAPI()
escape
De aquí en adelante, si necesitamos usar algún elemento del BBjAPI lo haremos a partir del objeto “copia” es decir miAPI! (nombre que le asignamos a la variable “contenedora” del objeto BBjAPI, y que podría ser cualquier otro nombre de variable, pero que para efectos didácticos tiene un nombre descriptivo).
Ya comenzamos, y debiéramos estar comprendiendo razonablemente bien los nuevos conceptos. Pero sigamos, para llegar a un objetivo muy importante en nuestro aprendizaje: crear nuestro primer formulario GUI recurriendo a la sintaxis de objetos.
Bajo el BBjAPI tenemos el objeto BBjSysGui que representa el canal SYSGUI que nos permite la creación y manipulación de formularios y controles gráficos en una apliación GUI. Para poder usar el canal SYSGUI tenemos que “instanciar” el objeto en nuestro programa, como lo muestra el mismo código que mostramos anteriormente.
rem "[PRG01] Mi Primer Programa en BBj
rem
rem "Obtiene una instancia del objeto BBjAPI
rem "=======================================
LET miAPI!=BBjAPI()
rem
rem "Abre el dispositivo SYSGUI
rem "==========================
SYSGUI=UNT
OPEN (SYSGUI) "X0"
rem
rem "Obtiene la instancia del objeto BBjSysGui
rem "=========================================
LET miSysGui!=miAPI!.getSysGui()
rem
escape
Bien, ya hemos logrado lo que en Vpro5 habría implicado sencillamente colocar el siguiente código:
SYSGUI=UNT
OPEN (SYSGUI)"XO"
Hasta el momento parece más complejo, pero ya veremos cuan sencillo se va tornando la programación bajo este nuevo concepto.
Ahora construyamos nuestro primer formulario GUI en BBj. Para esto debemos saber que bajo el BBjSysGui se encuentra el objeto BBjWindow que es el punto de entrada para crear objetos window, es decir, nuestros formularios GUI. Aquí tenemos dos tipos de objetos window: las BBjTopLevelWindow y las BBjChildWindow.
Comenzaremos creando las primeras y las segundas las dejaremos para más adelante en nuestra aprendizaje. Para esto crearemos una instancia del objeto window y lo dejaremos en una variable objeto que llamaremos con el mismo nombre: window!, el programa que estamos elaborando ahora se verá así:
rem "[PRG01] Mi Primer Programa en BBj
rem
rem "Obtiene una instancia del objeto BBjAPI
rem "=======================================
LET miAPI!=BBjAPI()
rem
rem "Abre el dispositivo SYSGUI
rem "==========================
SYSGUI=UNT
OPEN (SYSGUI)"X0"
rem
rem "Obtiene la instancia del objeto BBjSysGui
rem "=========================================
LET miSysGui!=miAPI!.getSysGui()
rem
rem "Valores para crear una ventana
rem "==============================
X=10
Y=10
ANCHO=400
ALTO=300
TITULO$="Ejemplo de una ventana GUI"
rem
rem "Establece el contexto actual
rem "============================
miSysGui!.setContext(0)
rem
rem "Crea la ventana
rem "===============
window! = miSysGui!.addWindow(X,Y,ANCHO,ALTO,TITULO$)
escape
Nuestra pantalla debiera presentar una apariencia similar a esta:
Nuestros primeros esfuerzos se centrarán principalmente en una de las ramas: el BBjSysGui. El manual incluido con la instalación está estructurado considerando esta ramificación. Por lo que seguir la secuencia de elementos será muy natural.
Más adelante hablaremos de los contextos en BBj, aunque si ya conoces Vpro5 te resultará familiar el concepto y su uso. Pero como puedes ver, hemos ido adentrándonos en los objetos a medida que vamos creando instancias de las objetos base o clases. Una vez creados en nuestro programa, comenzamos a ocupar sus elementos (o en terminología POO usamos sus atributos y comportamientos). Hemos incluido el comando escape en el ejemplo para evitar que el programa ejecute un END por defecto y cierre nuestro canal SYSGUI.
En este punto de nuestro programa ya podemos ver un formulario en pantalla sin nada, por lo que nuestro siguiente paso es empezar a incluirle objetos propios de un formulario GUI. Comencemos por agregar un control básico en casi cualquier formulario, un control StaticText o Label como se conoce en otros lenguajes.