Modelamiento en Diseño de Procesos

Apuntes de clase, curso-taller dirigido a la comprensión de los problemas de diseño de sistemas grandes y a la capacidad de diseñar sistemas pequeños, prototipos y micro aplicaciones


Knol relacionados:

Prototipos en VBA 

Curso de Visual Basic para Aplicaciones  


Descripción de la asignatura

La asignatura de Modelamiento en Diseño de Procesos es un curso-taller que trata el problema de analizar procesos complicados en la empresa y construir modelos que los describan y sirvan de base a los diseños lógicos de soluciones computacionales. El objetivo es desarrollar en el alumno las capacidades prácticas para enfrentar el problema de modelamiento, conocer las herramientas teóricas y prácticas así como conceptos fundamentales de la Ingeniería de sistemas para el desarrollo de software de calidad. Se enfatizará la diferencia entre el diseño y modelamiento de sistemas pequeños y grandes, las diferencias metodológicas y cuando aplicar cada una.

Se revisarán conceptos generales de modelamiento y Teoría General de Sistemas con su historia, potencialidades y limitaciones. Se estudiarán en extenso los problemas teóricos y prácticos asociados al modelamiento de datos, las tendencias y problemas de las distintas metodologías para el almacenamiento, recuperación y proceso de los datos. Este módulo será evaluado en la primera prueba.

Se enseñarán técnicas para desarrollar prototipos basados en la programación de aplicaciones de uso común en ofimatica, el taller de desarrollo de prototipos será parte importante en el desarrollo del curso. Este módulo será evaluado en la segunda prueba.

Se estudiará como primer caso la supervisión de un proyecto grande, ya implementado, en el cual los alumnos tendrán que analizar, detectar problemas, proponer soluciones y establecer procedimientos de control de su desarrollo. Este será evaluado como primer caso.

Se estudiará como segundo caso el modelamiento y diseño de un sistema para pequeña empresa, en el cual los alumnos tendrán que desarrollar desde cero partiendo por las entrevistas, casos de uso, manual de procedimientos, diseño lógico, documentación y análisis del diseño físico. Este será evaluado como segundo caso.

TEORIA
TGS, Modelamiento de datos, Gestión de datos, Bases de Datos, diseño en capas, modelos entidad-relación, orientación a objetos, modelos conceptuales, modelos evolutivos, modelos en cascada, análisis y diseño

PRACTICA
Diseño de entrevistas, modelado por prototipos, uso VBA para crear prototipos, mejora de procesos, microaplicaciones, persistencia, implementación

Condiciones

-Asistencia 80%, en cada clase se deberán firmar la planilla de asistencia, los alumnos que al final del curso no tengan el 80% de asistencia requerida serán reprobados automáticamente sin que esta decisión sea apelable ante el profesor, solo se puede pedir reconsideración al Jefe de Carrera. Lo mismo se aplica para las pruebas.

Recomendación: leer en inglés

Contenidos Programáticos

1. Fundamentos de la Teoría General de Sistemas
  • Conceptos básicos de Modelado
  • Modelado de Datos 
  • Historia
2. Bases de Datos
  • Relacionales
  • Jerárquicas
  • De red
3. El Diseño en Capas
4. Diseño y Técnicas de Entrevistas
5. Modelos Entidad-Relación
6. Diagramas de Modelos de Datos
7.  Modelado en Cascada
8. Modelado Evolutivo
9. Modelado por Prototipos
10. Herramientas Computacionales
  • Visio
  • VBA
11. Trabajo Práctico
12. Modelos de Procesos
13. Mejora de Procesos para Pequeñas y Medianas Empresas
14. El Modelo Orientado a Objetos
15. Análisis y Diseño
16. Modelos Conceptuales
17. Diagramas de Interacción y Clases
18. Persistencia
19. Implementación de una Solución
20. Trabajo Práctico

Fundamentos de la Teoría General de Sistemas

Historia

Galileo, Dos Nuevos Sistemas, el problema del colapso, por ejemplo de una viga soportada en sus extremos ¿que largo puede tener sin que se caiga bajo su propio peso?. Los modelos físicos (maquetas) pese a ser exactamente proporcionales no servían para predecir problemas de resistencia y colapsos, por ejemplo el problema de hacer un barco grande o un edificio de varios piso sin saber si va a resistir o no. Galileo desarrolló modelos matemáticos para describir la mecánica y la resistencia de materiales. Las matemáticas eran muy primitivas: geometría, lógica, aritmética básica, así es que los modelos resultaron complicadísimos, sin embargo muchas de sus demostraciones siguen siendo fundamentos de la mecánica clásica.

La idea de los modelos seguramente ha existido desde siempre: un muñeco es un modelo de ser humano, un calendario es un modelo de los movimientos del sol, en todos los folklores existe la idea de hacer miniaturas de las cosas para representarlas e influenciar sobre ellas (ekekos, alasitas). Las matemáticas aplicadas son el lenguaje de la ciencia y la herramienta más poderosa para modelar, una ecuación puede ser un modelo de algo real (por ejemplo la trayectoria de una bala de cañón está descrita casi exactamente por la ecuación de la parábola o las ondas de sonido por una ecuación tipo y=K*sen(x+algo), los modelos matemáticos son los más poderosos y exactos para problemas más o menos simples.

Probablemente el estudio de los fenómenos ondulatorios dió mucho impulso a la Teoría General de Sisteamas: fenómenos completamente distintos como las ondas en el agua al caer una pidra, el movimiento del péndulo de un reloj, un sonido propagándose por el aire, las ondas e luz o de radio obececen todas a ecuaciones del tipo y=K*sen(x+algo), o sea fenómenos muy disintos compartían el mismo modelo matemático. También se observaron en física muchas analogías entre fenómenos muy distintos que podían representarse con un mismo modelo, por ejemplo la amalogía entre un sistema hidráulico y uno eléctrico. Todas estas analogías y similitudes llevaron a formular en los años 30 la Teoría General de Sistemas basada en ciertos conceptos básicos:

1. Los sistemas en general, tienen características comunes a todos

2. Por lo anterior la TGS es integral, abarca todo lo que existe: sistemas físicos, químicos, biológicos, sociales, económicos, etc. uno se puede aproximar a cualquier fenómeno usando un enfoque de sistemas, que es una forma de aproximarse a la realidad

3. Un sistema en general se puede modelar como una caja negra, que tiene entradas, las procesa, entrega salidas y a veces se realimenta. El concepto de caja negra es algo que estudiamos desde afuera, sin importarnoc como funciona internamente, solo nos interesa saber que pasa con las entradas (estímulos) y con las salidas (respuestas) del sistema. Cuando se trata de conocer lo que pasa dentro de la caja negra estudiando como se modifican las salidas en función de las entradas eso se llama Ingeniería Reversa Un computador es un ejemplo clásico de caja negra: lo alimentamos con información y obtenemos respuestas sin tener idea del detalle de los millones de operaciones interbas involucradas ni como funcionan. Cuando usamos el computador lo hacemos con el enfoque sistémico, es decir de caja negra. Supongamos que necesito traducir un párrafo en inglés, voy al computador y entro al traductor en línea Babelfish, ingreso el párrafo (o sea alimento la caja negra con una entrada), cliqueo los botones adecuados y obtengo mi traducción.(o sea mi salida) ¿es necesario saber en detalle como opera el computador o como funciona el algoritmo traductor?, claro que no, para eso es el sistema de caja negra, los procesos de detalle lo hacen otros y nosotros no tenemos para que saber como funcionan: sería muy ineficiente si todos tuvieramos que aprender en detalle como funciona cada cosa. El concepto de caja negra es muy importante, volveremos sobre él a menudo.

4. Los sistemas pueden ser reales, que existen independientemente de nosotros y los podemos descubrir o no, ejemplos de sistemas reales son el clima, la economía, los organismos, etc. todo lo que tiene independencia de nosotros. También existen los sistemas ideales que solo existen en el intelecto, por ejemplo la lógica, las matemáticas, etc. Finalmente existen los modelos que son abstracciones de la realidad. Los modelos son el tipo de sistema que estudiaremos en este curso.

5. Un modelo es una abstracción de la realidad, una representación simplificada, exprimida de algo real a la que le hemos sacado todo lo irrelevante y le hemos dejado solo lo que más nos importa. Lo que es "relevante" o "irrelevante" es completamente relativo a lo que nos interesa obtener de nuestro modelo. En un muñeco lo relevante será que tenga un parecido físico con lo real, en el modelo de un puente lo relevante será que las características de resistencia, flexibilidad, etc sean parecidas, en el modelo de un negocio lo relevante puede ser las cantidades de dinero y como se comportan bajo distintas condiciones.

6. Los sistemas tienen a su vez subsistemas y también son parte de sistemas mayores. Por ejemplo el sistema de contabilidad de una empresa tiene distintos subsistemas (cuentas por cobrar, caja, activos, pasivos, etc.) pero también es parte de otros sistemas mayores (las finanzas de la empresa, las finanzas de la ciudad, del país, etc.). Por eso en la TGS es importante definir el ámbito de acción, o sea las fronteras dentro de las cuales estudiaremos un sistema.

La TGS tiene dos campos de actividad: Investigar el isomorfismo de conceptos, leyes y modelos en varios campos y facilitar las transferencias entre aquellos. promoción y desarrollo de modelos teóricos en campos que carecen de ellos y reducir la duplicación de los esfuerzos teóricos,. promoviendo la unidad de la ciencia a través de principios conceptuales y metodológicos unificadores.

MODELAMIENTO

Dentro de las competencias que un ingeniero debe poseer se encuentran aquellas orientadas a captar una cierta problemática y poder representarla en algún modelo usando, por ejemplo el lenguaje de modelación UML o un gráfico entidad relación.

El proceso de abstracción es una constante en el desarrollo de actividades que involucran el modelamiento. Este proceso es difícil de enseñar en términos tradicionales, es más bien una capacidad que los estudiantes ya traen y que es necesario orientar y potenciar para poder desarrollar las competencias específicas que posibilitarán un desempeño exitoso en el ámbito del modelamiento de sistemas y bases de datos.

La asignatura Modelamiento de Datos es una asignatura donde los estudiantes se enfrentan al problema de modelar sistemas informáticos, así como bases de datos.

La dificultad de enseñar a modelar
El proceso de modelamiento es un proceso inherentemente creativo y humano que cuenta con poco apoyo metodológico: existen numerosos lenguajes de modelación, pero no así métodos de modelamiento.

El proceso que dirige el modelamiento es la abstracción. La abstracción es el proceso mental por el cual se separa lo relevante de lo irrelevante La clasificación de algún elemento como relevante es un juicio, y como tal, está sujeto a la apreciación de cada individuo.

Los procesos que se desarrollan para analizar un problema y finalmente entregar un resultado en un modelo comunicable (por ejemplo un esquema entidad relación) son variados, desestructurados y dependen en gran medida de la forma de enfrentar los problemas de cada persona, la que a su vez puede estar fuertemente influenciada por la experiencia, capacidades y modelos mentales.

ADVERTENCIA

Teoría y Práctica, sistemas grandes y pequeños diferencias fundamentales, problemas que ocurren al aplicar conceptos desarrollados para sistemas grandes en sistemas pequeños. La TGS y el modelamiento no son la panacea y se aplican solo a ciertos sistemas, en sistemas pequeños y microaplicaciones todavía se usa la metodología antigua: un programador individual que se hace cargo de todo el proyecto, las técnicas en este caso son diferentes y las estudiaremos más adelante.

Que es La Teoría General de Sistemas

De un modo parecido a la Teoría de Conjuntos, la Teoría General de sistemas pretende hacer una abstracción que represente una gran cantidad de cosas distintas. El concepto de "sistema" es muy general, algunas definiciones de lo que es un sistema son:

"una cantidad de elementos y relaciones" (Klaus)

"una parte de la realidad, observable y que se puede describir" (Muller)

"algo que posee elementos, estructura, vecindad, recibe y envia magnitudes concretas a su vecindad" (Semard)

Como ven casi cualquier cosa la podemos considerar un "sistema" un sistema además suele tener partes o subsistemas: por ejemplo una industria es un sistema, uno de sus talleres es un sistema parcial de los cuales los operarios de torno serían otro subsistema. También la industria podría ser subsistema de un parque industrial, etc.

En la teoría de Sistemas distinguimos a un sujeto que observa y objetos que son estudiados. El sujeto estudia, interpreta y crea conocimientos, pero los objetos suelen tener muchas facetas de estudio y es imposible (además de inútil) estudiar su "realidad total" así se crea un sistema, que es "un análogo de un objeto real". Es decir el objeto y el sistema son dos cosas distintas,: el sistema es una imagen del objeto real que sirve para simplificar su estudio.

De aquí deducimos que para un mismo objeto pueden existir diferentes sistemas (abstracciones) que lo representen según que es lo que nos interesa estudiar.

La clave de la Teoría de Sistemas consiste en que, si bien todos los sistemas pueden ser distintos, existen estructuras y relaciones que son comunes a muchos de ellos: por ejemplo el movimiento del agua en un río y el comportamiento de una multitud de personas a la salida de un estadio son de una naturaleza material absolutamente distinta, pero se pueden establecer analogías entre ambos fenómenos. En la naturaleza existe una gran cantidad de sistemas análogos y si hacemos abstracción de la realidad material, vemos que muchos sistemas absolutamente distintos se pueden caracterizar por un mismo conjunto de relaciones.

Sistema Elemental (o Elemento Activo)

Un sistema elemental tiene a lo menos una magnitud de entrada y una de salida. Veamos un ejemplo práctico del asunto, por ejemplo si yo quiero estudiar el movimiento de la carga que maneja un puerto puedo definir un sistema sencillo que considere, la carga que entra al puerto y la que sale de él. Así el complejo sistema llamado "puerto" lo hemos reducido, por abstracción a una "caja negra" a la cual le podemos medir (digamos, en toneladas) la carga que entra para embarque y la carga que se desembarca de los buques. Con este sencillo modelo podemos estudiar, por ejemplo, en que épocas del año hay atochamientos, cuando hay más capacidad ociosa, etc. En fin, hemos creado un sencillo "modelo"

Nuestro modelo de puerto es un elemento activo que posee una vecindad (los barcos y la ciudad) a la que le entrega determinadas magnitudes (toneladas de carga), la vecindad también le entrega a nuestro puerto magnitudes por lo que ambos interactúan constantemente.

A nuestro modelo podemos complicarlo agregando otras variables para hacer más exacto nuestro estudio: por ejemplo la cantidad de trabajadores, la capacidad de las bodegas y la disponibilidad de camiones para transportar la carga. Todas esas magnitudes influirán finalmente en la cantidad de carga que en realidad se mueve y también existirán otras magnitudes externas, como los días con marejada que obligan a mantener el puerto cerrado, etc. Así vemos como el comportamiento de nuestro sistema está influenciado por si mismo y por el exterior.

Lo importante de este ejemplo es como hemos hecho abstracción de muchas cosas (como el paisaje, la forma de las instalaciones físicas, etc.) para concentrarnos solo en algunas pocas características que nos interesan: hemos creado un modelo que nos será mucho más útil, por ejemplo, que una fotografía o una película muy detalladas. Teniendo nuestro modelo podemos "jugar" con las variables para estudiar que pasaría, si establecemos las relaciones que nos interesan en forma matemática (por ejemplo una función que indique cuanto aumenta la capacidad de movimiento en relación a la capacidad de las bodegas) podemos calcular teóricamente y de antemano si es conveniente o no construir nuevas bodegas.

Hay que tener presente que no todos los sistemas son abstractos, o modelos, existen por supuesto los sistemas reales, pero estos sistemas abstractos es de los que más se ocupa la T.G.S. puesto que son los más útiles

Clasificación de los Sistemas

Grado de Abstracción 

* Abstractos
* Reales

Transformación en el tiempo 

* Estáticos
* Dinámicos

Complejidad 

* Simples
* Complejos
* Muy complejos

Certeza del comportamiento 

* Determinados
* Estocásticos (al azar)

Linealidad 

* Lineales
* No lineales

Armonía 

* Abiertos
* Cerrados

Estabilidad 

* Estables
* Inestables
* Indiferentes

Funciones o Relaciones de un Sistema
Ya hablamos algo de esto, cuando hacemos un modelo lo que tratamos es establecer cuales son las relaciones entre las magnitudes de entrada y las de salida. Así, en un modelo abstracto podemos tener varias entradas, varias salidas y una función de sistema que describe matemáticamente como se relacionan las salidas con las entradas, o sea

S=T(E)

Donde S es el conjunto de las magnitudes de salida, E el conjunto de magnitudes de entrada y T la función que las relaciona.

Siguiendo nuestro ejemplo práctico, podríamos establecer (por observación) que al aumentar la cantidad de camiones nuestro puerto aumentará su capacidad de movimiento de carga en un factor de x veces, etc.

También existen relaciones de retroalimentación, donde las magnitudes de salida influyen en las de entrada (por ejemplo si los embarques aumentan mucho, entrarán mas empresas de camiones a trabajar al puerto y viceversa)

Teoría de los Modelos
Ya hemos adelantado, informalmente, bastante acerca de los modelos. .

Un modelo fundamentalmente es algo que obtenemos después de un proceso de abstracción, es decir tomamos un sistema real y hacemos una imágen de el, más simple y más clara que el original.. Al construir un modelo tratamos de captar lo que es esencial en el sistema, lo que a nosotros nos interesa estudiar y lo que pensamos que nos servirá para ese estudio. Todo lo demás lo desechamos.

Un modelo facilita la comprensión de un sistema complejo, representando lo que es significativo para nuestro estudio, es una imitación de la realidad. Así, tenemos el objeto real, el sujeto que lo estudia y el modelo, que tiene relaciones de analogía o similitud con el objeto real y permite al sujeto obtener conclusiones relativas al sistema.

Clasificación de los Modelos

Modelos de Afirmación 
Estos modelos describen al sistema usando palabras, se usan en los sistemas más complejos donde no es factible determinar relaciones matemáticas. Estos modelos son muy debilmente predictivos y se limitan a hacer una descripción verbal y cualitativa del sistema. Sin embargo son muy usados en sistemas administrativos por ejemplo

Modelos Físicos 
Son objetos materiales usados para demostración y, en menor medida para experimentación cuantitativa. Un ejemplo típico son las maquetas

Modelos Gráficos 
Son modelos ideales que usan medios de expresión gráfica, un ejemplo muy característico son los mapas y planos

Modelos Formales 
Son los modelos abstractos, matemáticos ampliamente usados en la investigación científica. Consideran los parámetros variables escenciales de un fenómeno y sus relaciones descritas en forma de ecuaciones matemática

La anterior es solo una de las muchas posibles clasificaciones de los modelos, existen otras que, por ejemplo consideran las relaciones de analogía (modelos funcionales, estructurales, de comportamiento), o bien la finalidad de uso del modelo (de demostración, experimentales, para toma de decisiones) etc.

Como Modelar
Ahora veamos específicamente como se construye un modelo, de antemano aclaremos que por lo general no se trata de un proceso sencillo y que lo que viene a continuación son solo algunas orientaciones sobre las técnicas basicas de modelamiento

Ordenar las opiniones: para modelar se debe primero que nada observar el sistema y recoger información relevante, luego se determina sobre qué base será construído el modelo según las relaciones de analogía que se observen. También en esta etapa se determinará a que objetivo será construido el modelo

Elaborar los elementos esenciales y sus acoplamientos el modelo se va conformando de acuerdo a las relaciones de analogía encontradas

Experimentar con modelos: se trata de buscar modelos alternativos o variantes del configurado originalmente para ver si se puede perfeccionar la similitud con el comportamiento relevante del modelo real

Decidir la solución óptima: de todos los modelos experimentados se escoge al que represente al sistema de la mejor manera para nuestros propósitos

Prueba del modelo: se deben diseñar y ejecutar pruebas que confronten la capacidad predictiva del modelo con respuestas conocidas del sistema, de manera de detectar si hay omisiones o errores relevantes

Tres Técnicas Fundamentales
Existen tres técnicas muy usadas para modelar:

* El método de conclusiones por analogías
* El método de la caja negra
* El método de las aproximaciones sucesivas

Para obtener conclusiones por analogías consiste en buscar fenómenos semejantes cuya solución sea conocida, comparar sistemas distintos buscando semejanzas o analogías, en su comportamiento, su estructura o su materialidad

Para sistemas muy complejos un buen método es el de la caja negra, que consiste en un sistema (en principio definible) al que solo podemos influenciar alimentándolo y observando sus reacciones. Así podemos definir un comportamiento "macro" sin entrar a los detalles internos del sistema. El método de la caja negra es muy usado en el modelamiento de sistemas y también en nuestra vida diaria, cuando usamos televisores, teléfonos y muchos otros aparatos complicados sin preocuparnos de sus detalles de funcionamiento interno.

Observando como reacciona un sistema a nuestros estímulos podemos establecer funciones o relaciones de comportamiento, sin preocuparnos de lo que ocurre dentro.

El método de las aproximaciones sucesivas consiste en definir un resultado óptimo y tratar de obtenerlo ingresando magnitudes al azar al sistema, por medio de la prueba y error nos acercaremos al óptimo esperado lo que permitirá encontrar la relación buscada sobre el comportamiento del sistema. Este método que parece algo loco, es factible de aplicar usando computadoras, que pueden hacer todo el trabajo rutinario de prueba, error y aproximaciones sucesivas de manera automática.

En la Práctica
El análisis de sistemas, en la práctica se usa en las etapas de diseño lógico de los sistemas complicados. Los analistas de sistema son por lo general (o se espera que sean) gente del área de la ingeniería industrial o de la administración ya que, a diferencia de los ingenieros de software el diseño lógico está más cerca de la administración que de la parte relacionada con algoritmos y lenguajes.

El trabajo de un analista consiste en estudiar los requerimientos del sistema que se desea diseñar así como los flujos de la información y, en base a eso, entregar su producto que es el diseño lógico, que consiste simplemente en una lista detallada con las especificaciones que debe cumplir el sistema, una guía de criterios de diseño y procedimientos para que la gente de software se encargue de implementar.

En los sistemas pequeños el trabajo de diseño lógico y físico son llevados a cabo por una misma persona y a menudo el proceso de diseño lógico es informal y no deja especificaciones escritas. Sin embargo es recomendable para cualquier diseño, por simple que sea dejar escrita una lista de especificaciones del diseño lógico ya que esta formalización ayudará bastante a quienes tomen posteriormente las tareas de mantención del sistema, esta lista también constituye una salvaguarda contra cambios abruptos de diseño pedidos por el cliente una vez que el sistema está implementado.

Créditos

Una buena parte de los conceptos presentados aquí provienen de antiguos apuntes preparados por el profesor Federico Carozzi, que deben poder encontrarse en algún lugar de la Biblioteca de la Universidad de Santiago.

Desarrollando Competencias Específicas y Genéricas en Modelamiento de Datos, Marcela Varas, Depto. de Ing. Informática y Cs. de la Computación, Universidad de Concepción

Conceptos básicos de Ingeniería de Sistemas

La ingeniería de software surge frente a la crisis del software detectada a fines de los años 60 cuando los programas comenzaron a crecer en tamaño y complejidad. En un comienzo la programación completa para resolver un problema era hecha por una sola persona o un pequeño grupo de dos o tres personas que se repartían tareas, los primeros programas eran todos listas de instrucciones que se ejecutaban en una secuencia estricta por ejemplo

Inicio del programa
Aparece un menú de opciones
Si se escoge la opción 1 se ejecuta el procedimiento 1 (secuencia de instrucciones del procedimiento 1)
Si se escoge la opción 2 se ejecuta el procedimiento 2 (secuencia de instrucciones del procedimiento 2)
etc..
Vuelta al menú al terminar alguno de los procedimientos
Fin del programa

Estos se conocían como lenguajes de programación procedurales , es decir que consistían en listas secuenciales de procedimientos.

Los lenguajes procedurales aún se usan, todo lenguaje de bajo nivel  (o sea los que interactúan directamente con la máquina)  son procedurales y cuando programamos sistemas pequeños se puede usar el método procedural sin problema. Como los lenguajes procedurales son escencialmente listas de instrucciones son los que se usan en modo de consola (opuesto al modo gráfico o de ventanas).

Al comlicarse cada vez más los programas y aumentar de manera monstruosa la cantidad de instrucciones (hoy no es raro encontrar programas con millones de líneas de instrucciones), se hizo necesario el desarrollo en colaboración, los programas pararon a llamarse de preferencia sistemas y se hacían de manera modular por equipos de jefe de proyecto, analistas, programadores, documentadores, etc.

Otra consecuencia de estos cambios fue la necesidad de desarrollar los sistemas en módulos porque era imposible que una sola persona pudiese entender o controlar un sistema en su totalidad, esta modularidad desarrolló el concepto de cajas negras y aislación en capas donde cada módulo era una cápsula cerrada de código a la que se le conocían sus entradas y salidas, pero los detalles internos quedaban restringidos y ocultos para quienes trabajaban en los demás módulos, así las cápsulas o módilos de código se podían ensamblar como piezas de un Lego y también podían reusarse para otros programas.. Los sistemas dejaron de ser un solo archivo mosntruosamente grande para convertirse en un ejecutable principal muy grande que llamaba a las funciones de otros ejecutables relacionados llamados bibliotecas. Por ejemplo en Windows estas bibliotecas son los archivos con extensión dll, ocx y otras.

Hasta fines de los sesentas la programación de computadores era una especie de arte  donde personas muy dotadas (los programadores) veían un problema, diseñaban un modelo abstracto de solución, diseñaban los procedimientos lógicos y finalmente codificaban todos estos procedimientos. Sin embargo al crecer la complejidad de los programas ya nadie era capáz de manejar un diseño por si solo y la programación "artística" colapsó por múltiples razones:

  • Al trabajar en equipo no todos los programadores eran igualmente hábiles, esto creaba enormes cuellos de botella en la producción de un sistema.
  • Como la codificación dependía mucho de la habilidad del programador, lo normal era que el único que entendía el código era quien lo había programado, o sea los programadores se convertían en indispensables e irremplazables.
  • Al no existir procedimientos estrictos de desarrollo el código resultaba enredado, lleno de errores que se iban parchando en el camino y quedaban sin documentar, el desarrollo se demoraba, etc.
Para corregir esta situación surgió la Ingeniería de Software con el objetivo de "la producción sistemática y el mantenimiento de productos de software, su desarrollo y modificación en el tiempo previsto y dentro de los costos estimados"

NOTA IMPORTANTE: Para sistemas pequeños muchos de los problemas mencionados no existen y por ello algunos de los criterios desarrollados por la Ingeniería de Software no se aplican.

Los productos de software (que en adelante llamaremos Sistemas) pueden ser de dos clases
  • Genéricos (por ejemplo Word, Excel, etc.)
  • A la medida (por ejemplo el software del control de las fronteras)
Los sistemas, además de el conjunto de archivos con ejecutables compilados y bibliotecas usualmente tienen los siguientes componentes adicionales
  • Documentación de los requerimientos (casos de uso)
  • Documentación de los diseños (especificaciones de diseño)
  • Código fuente
  • Planes de prueba (casos de prueba)
  • Manual de operación y ayuda (manual de usuario)
  • Instrucciones de instalación
  • Procedimientos de mantenimiento (planes de respaldo, protocolos de reporte de error, planes de contingencia, etc.)
Como se desarrolla un sistema
  1.    Planificación y estimaciones: en esta etapa se planifican las actividades, se asignan los tiempos, los requerimientos de recursos humanos, físicos y se estima el presupuesto de cada etapa así como el presupuesto total del proyecto
  2. Análisis de los requisitos: aquí se descompone el problema que se pretende modelar en sus detalles, determinando que es lo que se requiere que haga el sistema
  3. Diseño: en esta etapa se crea el modelo y el diseño lógico con todas las entradas, salidas y procesos que debe ejecutar el sistema
  4. Codificación: el diseño creado en la etapa anterior se materializa escribiendo en lenguaje de programación las instrucciones para llevar a cabo cada una de los módulos según las especificaciones del diseño lógico
  5. Prueba: la etapa de prueba es simultánea a la de codificación a nivel de detalle pero también posterior, cuando se ensamblan los módulos. Finalmente cuando se entrega todo el sistema para producción comienza una tercera fase de la etapa de prueba que es para todo el sistema bajo condiciones reales.
  6. Mantenimiento: en esta etapa se agregan nuevos módulos, se modifican o se quitan según vayan cambiando los requerimientos del sistema, se ejecutan programas de respaldo de datos y sistema, etc.
Concepto de Calidad de Software

La calidad de un software tiene que ver con la percepción subjetiva acerca de su desempeño, robustez, prestaciones, etc. y se percibe en dos niveles:

  • Nivel Externo, es como perciben el software los usuarios del sistema
  • Nivel Interno, es como perciben el software los profesionales de la computación
En el nivel externo, la percepción de calidad suele variar mucho según las expectativas de los usuarios algunas de estas son objetivas como:
  •  Corrección: cuando el sistema ejecuta sin errores todas sus funciones, tal como han sido especificadas en el diseño.
  • Robustez: cuando el sistema no se cae en condiciones excepcionales o anormales
  • Modificabilidad: la capacidad para adaptarse al cambio en sus especificaciones
  • Compatibilidad: capacidad para acoplarse y trabajar en conjunto con otros sistemas
  • Ergonomía: capacidad para hacer las tareas con la mayor facilidad para el operador, evitando la duplicación de entrada de datos, el paso innecesario por varias etapas para hacer una tarea, etc.
  • Integridad: capacidad para protegerse contra accesos no autorizados, robo de información, modificación maliciosa, etc.
  • Facilidad de uso: aprendizaje sencillo, operación sencilla, reportes de calidad
Sin embargo existen otros criterios de percepción de calidad por parte de los usuarios que, sin ser tan objetivos, son los que causan los mayores conflictos:
  •  Disconformidad con el diseño del sistema: pese a que el diseño se construye en base a encuestas y estudio de las necesidades de los usuarios, este no es siempre 100% funcional a sus intereses porque existen muchos otros criterios que el diseño debe considerar, por ejemplo al mejorar la seguridad y los controles normalmente se perjudica la ergonomía, los jefes pueden haber introducido requisitos adicionales al sistema para prestaciones y trabajos que antes no se efectuaban, el sistema puede ser menos robusto ante el ingreso equivocado de datos, etc. En general los usuarios siempre comparan el nuevo sistema con el antiguo y distintos usuarios tienen distintas prioridades, por lo que no existe un sistema que pueda dejar a todos conformes por igual, los operadores desearan hacer lo mismo con menos trabajo, los clientes desearán tener prestaciones adicionales, los jefes más control y seguridad, etc. todos esos requerimientos están frecuentemente en conflicto por lo que no es raro que la percepción de calidad difiera para los diferentes usuarios.
  • Aversión al cambio: operadores y usuario están acostumbrados al sistema antiguo y se molestan al tener que cambiar sus métodos de operación y aprender otros nuevos.
  • Falsos errores de sistema: producidos por errores de operación durante la curva de aprendizaje, durante el período de prueba en explotación suelen producirse fuertes tensiones y recriminaciones mutuas entre operadores y el equipo de desarrollo por esta causa 
En el nivel interno algunos de los principales factores de calidad son:

  • Modularidad: que es la capacidad de cada componente del programa de funcionar de manera independiente, posibilitando el reemplazo, reutilización, etc. sin tener que afectar al sistema completo
  • Legibilidad: el código debe estar escrito de manera clara y tan auto documentado como sea posible en cada uno de sus módulos de manera que cualquiera lo pueda entender, mantener, reparar, etc.
Ciclo de vida del software

El ciclo de vida son las etapas por las que pasa un sistema desde su concepción hasta su explotación en régimen. Existen varios modelos de los cuales revisaremos tres:

Clasico
El ciclo de vida clásico consiste en el desarrollo secuencial en una serie de pasos, cada paso genera las entradas y la documentación para el siguiente:

Entrevistas
Especificaciones de casos de uso
Diseño lógico
Diseño Físico
Casos de Prueba
Documentación
Producción

Este ciclo de vida todavía se ocupa para el desarrollo de sistemas pequeños por su simplicidad, pero en la mayoría de los sistemas se usa una variante llamada

Ciclo Clásico en Cascada
En este caso también se recoge información, se hacen especificaciones de diseño, se hace un diseño lógico y finalmente se codifica, la diferencia es que el flujo no es secuencial sino que las correcciones afectan no solo a la etapa inmediatamente anterior sino a todas las etapas. Al crecer los sistemas aparecen una serie de inconvenientes en el desarrollo en cascada, como:

    * Es difícil imaginar de antemano los requerimientos de las etapas que siguen
    * Muchos problemas no siguen un flujo secuencial
    * Los errores se detectan solo cuando se pone a prueba todo el sistema

Ciclo de vida por prototipado
Los prototipos son versiones iniciales de un producto o un módulo, que permiten que el cliente y el futuro operador vean como se va a comportar, den sus impresiones y críticas, ayudan a establecer las necesidades reales del cliente quien muchas veces no las tiene claras al momento de ser entrevistado.

PROTOTIPEANDO

"Un buen científico es una persona con ideas originales. Un buen ingeniero es una persona que hace diseños que funcionan con un mínimo posible de ideas originales"
Freeman Dyson
 
EL DISEÑO EN CASCADA
 
La ingeniería de sistemas se preocupa del  análisis y modelamiento del sistema que se pretende construir. El trabajo consiste a grandes rasgos en entender el problema, fijar las prioridades y especificarlas en un modelo lógico que normalmente se concreta como un listado exhaustivo de especificaciones sobre que es lo que el programa debe hacer, las entradas, procesos y salidas..

El trabajo de la ingeniería de sistemas tiene que ver con la organización, las necesidades y expectativas de los clientes, la idea es definir y ordenar las prioridades en una capa lógica abstracta, antes de enredarse con los detalles técnicos de la codificación y es por eso que se le da gran importancia al trabajo de encuestas en esta etapa, de manera de tener claras las prioridades y expectativas.

Luego viene el trabajo de ingeniería de software que consiste en codificar las especificaciones entregadas y convertirlas en un programa que funcione. El trabajo en una primera instancia consiste en construir prototipos de las interfases de usuario, es decir un programa "de mentira" para determinar las mejores interfases hombre-máquina y, una vez elegido esto dedicarse a codificar y optimizar los procesos que el sistema debe realizar, todo esto apegado a las especificaciones entregadas por el diseño lógico. La construcción de prototipos semi funcionales es de gran ayuda al momento de probar el comportamiento real de las ideas del diseño.

Esta es la teoría. La construcción de un programa debe ser un proceso en cascada donde el diseño ideal debe preceder a la codificación. En el desarrollo de programas computacionales según se nos ha enseñado, existen dos etapas claramente definidas: el diseño lógico y el diseño físico. En la realidad sin embargo,  esta separación ha sido fuente de diversos problemas
 
POR QUE SE DISEÑA EN CASCADA
 
Esta separación entre diseño lógico y el diseño físico es consecuencia de los problemas de crecimiento de tamaño y complejidad en los sistemas. En un principio ambas etapas estaban estrechamente relacionadas, y lo siguen estando en el caso de los sistemas pequeños donde trabaja solo un programador o un pequeño grupo de personas.

Pero al hacer sistemas más complejos y dividir las tareas entre un equipo de programadores era necesario fijar prioridades y criterios de diseño de antemano, de manera que todos trabajen bajo normas claras y criterios comunes. Esto evita el problema de desvíarse de los grandes objetivos por percepciones o necesidades particulares de alguno de sus subsistemas. También divide el trabajo en una parte creativa y normativa (diseño lógico) y otra mecanizada y sujeta a normas (diseño físico).

El diseño en cascada ha formado una verdadera cultura que separa a analistas y programadores. Harry Boehm de la Universidad de California del Sur cuenta su experiencia al respecto: "Cuando tratamos de introducir el uso de prototipos en proyectos con alta interacción de usuarios en TRW, los ingenieros de software, resistiéndose al cambio, golpeaban la mesa y gritaban, "¡No pueden hacer esto!  ¡hacer prototipos es codificar sin haber pasado la revisión crítica del diseño, esto esta absolutamente prohibido por las políticas corporativas!" , tomó años deshacer las muchas formas en que el modelo de cascada se había infiltrado en varios aspectos de nuestra cultura corporativa tales como el marketing, preparación de propuestas, estimación de costos, contratos, contabilidad y gerenciamiento"
 
¿Y CUAL ES EL PROBLEMA?
 
Hay un viejo cuento de un ingeniero de sistemas que decía haber diseñado finalmente un software que podía rivalizar con el cerebro humano. Al pedírsele que lo demostrara entregó una larga lista con las especificaciones comunes de un computador a las que había agregado las especificaciones de "imaginación", "conciencia de si mismo", "lenguaje sofisticado" etc. "Bueno", dijo a modo de explicación "allí tienen el diseño, ahora solo es cosa de los programadores y los ingenieros de hardware implementarla. Lo principal ya esta hecho.

Bueno, ese es uno de los mayores problemas de trabajar en abstracto desentendiéndose de los problemas prosaicos tales como la codificación, los recursos disponibles, costos  y el rendimiento. Los ingenieros de sistema vienen normalmente de las áreas de la ingeniería industrial o de la administración (ingeniería comercial en Chile), no son fuertes en programación y a menudo ven con cierto desprecio la labor del programador, considerándola mecánica y poco creativa.

No es raro que los diseños lógicos, al desentenderse de los detalles del mundo real tales como las limitaciones de hardware o la complicación excesiva en el código terminen en una serie de especificaciones y requisitos que no es factible de implementar con éxito. Esos son los conocidos "desastres informáticos" o sistemas que llevan mucho tiempo, esfuerzo y dinero en desarrollarse y que nunca llegan a funcionar del todo bien (muchos simplemente jamás funcionan).
 
UNA HISTORIA REAL
 
"A comienzos de los 80, una gran organización del gobierno contrató a TRW para desarrollar un ambicioso sistema de consultas y análisis. El sistema proveería a más de 1.000 usuarios, dentro de un gran complejo de edificios, con poderosas capacidades de análisis y consultas para una gran base de datos dinámica.

TRW y el cliente especificaron el sistema usando el modelo clásico de cascada de la ingeniería de sistemas, basado principalmente en encuestas a usuarios y análisis de rendimiento de alto nivel, llegaron  a establecer como requisito fundamental la respuesta a cualquier consulta en menos de un segundo.

Dos mil páginas de especificaciones más tarde, los arquitectos de software encontraron que este rendimiento solo podía alcanzarse con un diseño muy especializado, que intentara anticipar patrones de búsqueda y hacer uso extensivo de cachés de datos. Como resultado se estableció que se requerían al menos 25 super-mini computadores, para hacer los cachés y un algoritmo cuya complejidad desafiaba cualquier clase de análisis simple. Esto llevó a un costo estimado de 100 millones de dólares, debido principalmente al requisito de respuesta en menos de un segundo.

Encarando este poco atractivo prospecto, se decidió desarrollar un prototipo de la interface de usuario y las capacidades representativas para probarlas. Como resultado se vio que un tiempo de respuesta de cuatro segundos sería satisfactoria para los usuarios el 90 por ciento de las veces. Un sistema con respuesta de cuatro segundos bajó los costos de implementación a solo 30 millones de dólares."

(Barry Boehm, "A Large Secuencial-Engineering Near-Disaster" Revista "Computer" marzo 2000, pag. 115)
 
ES NECESARIO UNIFICAR
 
La historia anterior muestra los peligros de tener diseñadores lógicos absolutamente separados de las consideraciones físicas de codificación, limitaciones del hardware, rendimiento y costo de los sistemas. Es necesario volver a revisar muchos conceptos que se daban por inamovibles, debe existir una interaccion y realimentación entre el diseño lógico y el físico y si se puede codificar y construir prototipos antes de completar las especificaciones del diseño lógico. La idea de una cascada con una etapa tras otra esta siendo reemplazada por un modelo espiral, los ingenieros de software ya no se quedan sentados esperando las especificaciones de la ingeniería de sistemas, sino que participan activamente en el proceso de creación y definición de especificaciones, agregando el trabajo con prototipos a las tradicionales encuestas para lograr productos con mayor base en el mundo real y no solo ejercicios teóricos de optimización.

En USA ya hay varias iniciativas para promover este cambio cultural en el diseño de sistemas, partiendo por el Integrated _Capability Maturity Model de la FAA y la iniciativa del SEI y el Departamento de Defensa llamado proyecto de integración CMM I (la I es de Integration). Más información sobre estas iniciativas conocidas como desarrollo unificado o integrado de sistemas (en oposición al tradicional modelo de desarrollo en cascada) puede encontrarse en http://www.sei.cmu.edu/cmm/cmmi/
 
¿QUE TIENE QUE VER ESTO CON LOS SISTEMAS PEQUEÑOS?
 
Bastante, la herramienta por excelencia para desarrollar prototipos es el Visual Basic y la experiencia de los desarrolladores de sistemas pequeños, acostumbrados a encarar los aspectos lógicos y físico de los sistemas es muy valiosa a la hora de desarrollar prototipos e interfases hombre-maquina. Un nicho más de desarrollo para los especialistas en sistemas pequeños
 
CREDITOS
Fundamentos de Ingeniería de Software, Marcelo Visconti, Hernán Astudillo, Departamento de Informática, Universidad Técnica Fderico Santa María

"Unifying Software Engineering and Systems Engineering" de Barry Bohem, aparecido en la revista "Computing" de marzo del 2000.

De Los Archivos a las Bases de Datos

Los computadores, desde su inicio se han convertido en la herramienta para modelar por excelencia porque tienen dos potentes características para esta tarea: pueden almacenar información de manera persistente y pueden ejecutar procedimientos automatizados (cálculos, búsqueda, selección, etc.).

Las primeras aplicaciones hacían una diferencia tajante entre datos y procesos, los datos eran información estática, guardada en algún lugar que se podía manipular (procesar) por medio de programas, entonces los datos se guardaban en archivos que podían ser de tamaño más o menos fijo (como un archivo con los datos de cuenta para un programa de cuentas corrientes) y otros de tamaño variable (como los archivos de movimiento que crecen en el tiempo), en este esquema tenemos:

Archivo de datos
Archivo de datos ----------- Programa
Archivo de datos

En este esquema, que todavía se usa en sistemas pequeños, el programa es fundamental y actúa sobre los datos, recuperándolos, buscando o modificando y luego los muestra arreglados de cierta forma. Volviendo al ejemplo de cuentas corrientes podemos tener un módulo de programas -por ejemplo- para listar el analítico de una cuenta (la cartola) este módulo pediría la identificación de la cuenta (clave de búsqueda) y se iría al archivo de nombres de cuentas, para recuperar el nombre del titular, su RUT, su límite de crédito, etc. Esos son los datos a desplegar en el encabezado de la cartola.

Luego el programa recorrería secuencialmente el archivo de movimientos, que tiene los registros de todas las cuentas almacenados en secuencia, seleccionando solo los registros que corresponden a la cuenta solicitada y los desplegaría como líneas de la cartola, del más antiguo al más nuevo.

Operaciones con Archivos

Esta explicación práctica sobre archivos y bases de datos en Visual Basic, está orientada al principiante y también para los que creen que la única forma de almacenar información es en una  base de datos.

Almacenar datos en una tabla

Esta es la forma mas usada por ser sencilla e intuitiva, es lo que usan las bases de datos "relacionales" y los archivos planos de tipo "random" o aleatorio. Consiste en definir campos, nombres y largos, con lo que describimos una grilla cuyas "lineas" corresponden a "registros" y las "columnas" a "campos". Los que conocen las bases de datos o las hojas de cálculo conocen bien esta idea, por
ejemplo:
NRONOMBREDIRECCIONTELEFONO
1PEDROLOA 123223344
2JUANACACIAS 222345566
3DIEGOCODORNICES 324765544


También existieron en su época las bases de datos jerárquicas (recuerdo la Q&A que era sensacional) pero nunca tivieron tanto éxito como las relacionales. El hecho es que estamos acostumbrados a almacenar datos en tablas

Los Archivos Random

¿Como se guarda esto en un archivo plano usando Visual Basic?, pensemos un poco en lo que necesitamos para que quede físicamente grabado en el disco:
Necesitamos guardar en algún lado la cantidad de registros almacenados, para saber en que posicion se guardará el registro siguiente (en el ejemplo mostrado hay 3 registros). Esto podria hacerse en otro pequeño archivo o, por ejemplo, en la primera posicion del mismo archivo, el que quedaría físicamente así:

3

PEDROLOA 123223344
JUANACACIAS 222345566
DIEGOCODORNICES 324765544

Nótese que eliminamos el campo correspondiente al "número", éste no necesitamos grabarlo pues está implícito en la posición física donde va grabado el registro.Luego necesitamos grabar los datos "alineados" es decir todos los campos deben tener el mismo largo. Supongamos que definimos de antemano que el campo "nombre" debe tener 30 caracteres, el campo "direccion" 40 caracteres y el campo "teléfono" 20 caracteres ¿como los alineamos? Simplemente agregándole espacios en blanco. Por ejemplo si entramos el valor "PEDRO" en el campo de nombre (5 caracteres) tendremos que agregarle 25 espacios en blanco, a "JUAN" (4 caracteres) le agregamos 26 espacios, etc. No es necesario hacer una rutina para agregar espacios pues esto se hace fácilmente en Visual Basic con:

Type Registro_de_agenda
     Nombre as string * 35
  
Direccion as string * 40
 
 Telefono as string * 20
End Type

Global Agenda as Registro_de_agenda 

Este código se guarda en un módulo .Bas donde van las declaraciones, valores de inicialización y variables globales o públicas, etc. Las instrucciones Type....End Type convierten los valores que entramos en esas variables en largo fijo y la declaración Global (o Dim, Public o Private, según nos convenga) sirve para crear variables "con apellido" llamadas "tipos de datos definidos por el usuario", así de ahora en adelante las variables se llamarán: 

Agenda.Nombre 
Agenda.Direccion 
Agenda.Telefono 

Esta es una notación muy conveniente y emparentada con la notación  de objetos: es decir el objeto "Agenda" tendría las propiedades "nombre", "dirección" y "telefono" Luego, para crear un archivo del tipo "random" nos falta usar solo tres instruciones más "Open" (abre un archivo), "Put" (graba un registro), "get" (lee un registro)  y "Close" (cierra el archivo). 

Para "iniializar" un archivo con 1000 registros en blanco por ejemplo, abrimos una Form, le colocamos un botón con el Captios "Inicializar (Borrar todo)" y le programamos el evento click con: 

Sub Inicializar()    
     Open "Archivo_de_Agenda" for Random as 1    
     For z=1 to 1000         
         Agenda.Nombre=""       
         Agenda.Direccion=""        
         Agenda.Telefono=""        
         Put 1, z, Agenda    
     Next z    
     Close 
End Sub 

¿Se podría usar el archivo sin inicializarlo? si, el único inconveniente sería al leer registros vacíos aparecería "basura" es decir cualquier información que haya en el buffer en ese momento, lo que es bastante incómodo si estamos listando por ejemplo 

Colocando los textboxes Text1, Text2 y Text3 en el form para ingresar los campos, la rutina para agregar registros sería

Sub agregar()     
     Open "Archivo_de_Agenda" For Random As 1     
         rem     
         rem leer el indice, incrementar y grabarlo     
         rem 
         Get 1, 1, Agenda     
         ultimo = Val(Agenda.nombre)     
         If Val(ultimo) = 0 Then ultimo = 1 rem si esta vacio lo pone en 1     
         Puntero = ultimo + 1     
         Agenda.Nombre = Puntero     
         Put 1, 1, Agenda     
         rem     
         rem puntero almacena donde debe grabarse el nuevo registro      rem     
         Agenda.Nombre = Text1.Text     
         Agenda.Direccion = Text2.Text     
         Agenda.Telefono = Text3.Text     
         Put 1, Puntero, Agenda     
         Close 
End sub 

Para listar el archivo simplemente se lee el indice y se hace un ciclo for - next partiendo desde la posición 2 asi: 

Sub listar()      
     Open archivo For Random As 1      
     rem leer el indice      
     Get 1, 1, Agenda      
     ultimo = Val(Agenda.Nombre)     
     rem listar      
     For z%=2 to indice            
         Get 1, z%, agenda             
         List1.AddItem Agenda.Nombre        
     Next z 
     Close 
End Sub

Existen dos problemas que a menudo están relacionados al usar archivos random, son los de buscar (y encontrar) rápidamente un registro y presentar el archivo ordenado según algún criterio. En ambos casos se usa uno o más  archivos auxiliares de índice, que almacenan la ubicación física de los registros en distintos órdenes según se requiera. 

Programar estos índices y usar métodos de ordenación y búsqueda son procedimientos más o menos complicados, y es una de las razones principales que justifican el uso de motores de base de datos que automatizan estas dos tareas. En la programación convencional sin usar bases de datos, se usan normalmente el método ISAM (Indexed Sequencias Access Mode) y el algoritmo Quick Sort. 

En los archivos secuenciales los datos no se almacenan en campos de largo fijo sino como una secuencia continua de datos con algúl caracter delimitador que los separa, el ejemplo anterior quedaría asi: 

Pedro,Loa123,223344,Juan,Acacias 222,345566,Diego,Codornices 324, 

Un archivo secuencial es como una tira de salchichas donde los datos solo pueden ir agregandose al final y se debe leer y escribir la secuencia completa cada vez. Son por lo general complicados de actualizar, ordenar y bastante lentos, pero tienen algunos usos interesantes como por ejemplo grabar archivos de texto completos y particularmente archivos del tipo .ini, muy usados en Windows para ingresar settings 

Para usar archivos secuenciales en almacenamiento de datos el procedimiento es trabajar con toda la sarta de salchichas almacenada en un array en memoria. Esto limita bastante el tamaño y el rendimiento de estos archivos. Me parece que las hojas de cálculo usan una estrategia similar y por eso son tán limitadas en cuanto al manejo de hojas grandes. Para leer un archivo secuencial de texto en una lista List1, usamos: 

Sub leerarchivo()         
     Dim Lineatemporal As String         
     List1.Clear         
     Open "Archivo_de_Datos" For Input as 1         
     While not EOF(1)                    
     Line Input 1, Lineatemporal                    
     List1.Additem Lineatemporal                 
     Wend         
     Close 1 
End Sub 

Y para escribir (agregar al final) en un archivo secuencial de texto, usamos:

Sub escribearchivo()          
     Open "Archivo_de_Datos" for Append Shared As 1           
     Print 1,  "dato a grabar"           
     Close 1 
End Sub 

Este es un ejemplo típico de como trabajan los sistemas procedurales, o sea donde lo más importante es el proceso. Estos sistemas fueron los primeros en desarrollarse y tienen muchos inconvenientes a medida que el volumen de datos crece demasiado (los procesos de búsqueda y recuperación se hacen muy lentos).  

Otro problema es cuando los procesos se complican demasiado, los programas crecen mucho y llegan a ser imposibles de comprender, excepto por el propio programador que los hizo. Otro problema de estos sistemas es que el diseño depende mucho de como están almacenados físicamente los datos (en que formato), los datos se guardaban en formatos propietarios e incompatibles con otros programas. 

Bases de Datos

Esto se llamaba el problema de la dependencia físico-lógica. "Poco a poco, el centro de gravedad de la informática, que estaba situado en el proceso, se desplazo hacia la estructuración de los datos, siendo actualmente los aspectos relacionados con este tema un eje fundamental alrededor del cual gira una gran parte del conjunto de problemas con los que se enfrenta todo diseñador de un sistema de información. 

Se cambia, por tanto, de sistemas orientados hacia el proceso a sistemas orientados hacia los datos, donde estos adquieren el protagonismo, pasando desde el plano más bien oscuro y difuso en el que estaban situados a ocupar un lugar privilegiado en el interés de todo informático. 

Surge así, a finales de los sesenta y principios de los setenta, la primera generación de productos de bases de datos en red (basados en lo que posteriormente se conocería por modelos jerárquicos y Codasyl), entre los que destacaron por su impacto el IMS de IBM y el IOMS de Cullinet. Estos productos, si bien resultaban bastante eficientes, presentaban lenguajes procedimentales, que obligaban al programador a navegar (registro a registro) por la base de datos, y que no disponían de la suficiente independencia físico/lógica, lo que conllevaba una escasa flexibilidad" (Mario Piattini Velthuis). 

La base de datos relacional se inventa en 1970, básicamente consiste en un conjunto de reglas (un modelo) teóricas que independizan las operaciones sobre los datos de la forma en que estos están almacenados físicamente para ello una base de datos relacional tiene tres componentes: -Un motor de base de datos DBMS, que es el conjunto de programas que maneja la creacción y acceso a los datos físicos, distintos motores de bases de datos deben llevar al mismo modelo en la capa superior, el DBMS es el que aisla y relaciona la capa superior con los datos físicos, tiene tres subcomponentes: 

-Un lenguaje de definición de datos DDL para definir y documentar las estructuras de datos 
-Un lenguaje de manipulación de datos DML para hacer procesos con los datos 
-Un lenguaje de consultas SQL para hacer consultas y obtener vistas de los datos 

La base de datos relacional es la más usada por su sencillez y porque coincide con nuestra idea intuitiva de como se deben almacenar los datos, relacional, en palabras simples significa "organizadas como una tabla, en filas y columnas" pero también existen otras dos formas de organización: jerárquica y en red. La organización jerárquica sigue el modelo de un organigrama, un arbol geneológico, etc. con un nodo "raíz" del cual se van descolgando subnodos, la clave de una organización jerárquica es que cada hijo solo puede tener un padre, o sea solo una dependencia hacia arriba como muestra la figura:




La tecnología XML, de gran importancia por su potente aplicabilidad en sistemas de Internet usa un esquema jerárquico para organizar los datos.

La organización en red es escencialmente igual que la jerárquica pero con el agregado que los hijos pueden tener varios padres, en estas bases de datos se usa un registro conector para indicar con quienes está conectado el dato. Son muy poco usadas por su complejidad.
El Diseño en Tres Capas

Las bases relacionales normalmente se usan en conjunto con la arquitectura en tres capas (3 Layer Architecture) que consiste en estandarizar y aislar las operaciones en capas:

1. Capa Física, es el nivel real donde están almacenados los datos (por ejemplo el disco duro) como se almacenan, en registros, como se indexan, etc. Este nivel tiene asociada una representación de los datos en registros y campos, denominada esquema físico. Es un nivel restringido a muy pocas personas.

2. Capa Conceptual, corresponde a una visión de la base de datos, es la organización lógica de los datos sin importar donde están físicamente almacenados.

3. Capa de Visión, los usuarios solo tienen acceso a pequeñas porciones de la capa conceptual (vistas o subconjuntos), rara vez al conjunto total. Por ejemplo un cajero debe tener su visión restringida a lo que necesita usar y no a ver los sueldos de sus superiores, la capa conceptual define y divide estas parcelas para los usuarios.

Ventajas de las bases de datos

1. Independizan los datos de los procesos, si se cambia de programa noes necesario cambiar los datos y viceversa, porque son bases estandarizadas, bajando así los costos de mantenimiento.

2. Coherencia, reducen la redundancia (usando la normalización) y se evitan las inconsistencias (que un mismo dato tenga dos valores distintos al mismo tiempo)

3. Los datos son más disponibles, ni las plicaciones ni los usuarios son "dueños" de los datos por tecnología, solo por diseño, los datos pueden ser usados por distintas aplicaciones y distintos usuarios. Los datos pueden usarse aunque no haya ningún programa, usando solo el SQL.

4. Procedimientos normalizados, iguales para todos los casos, no hay procedimientos excepcionales, los accesos y operaciones permitidas están claramente definidos.

5. El acceso concurrente es mucho más sencillo, por ejemplo varios usuarios pueden acceder simultáneamente a una misma base de datos e incluso a un mismo registro, las bases de datos tienen mecanismos incorporados para evitar inconsistencias a diferencia de los archivos tradicionales. 

Desventajas de las Bases de datos

1.  Requieren de muchos programas e instalaciones para funcionar: bibiotecas, APIS, módulos, etc. lo que dificulta la portabilidad, no es sencillo portar ni migrar una base de datos. La migración entre sistemas legados a un nuevo sistema es uno de los procesos más críticos y complicados, aunque hay muchas utilidades para esto.

2. Aunque estándares dentro de su ámbito, el esquema de almacenamiento físico es propietario y muy oculto, cuando una base de datos se corrompe es muy difícil recuperar los datos que han quedado intactos, porque su acceso físico está muy encapsulado.

3. Vulnerabilidad, las bases de datos tienden a ser monolíticas y por lo mismo muy vulnerables, hay que tener mucho cuidado con las políticas de respaldo.

Algunas marcas de base DBMS:

- MySql, tiene licencia GPL (gratis) basada en un servidor, es muy rápida pero su rendimiento decae cuando almacena demasiados datos

-PostgreSqul y Oracle, son de los más poderosos, para grandes volúmenes de datos

-Access, es el DBMS "casero" de Microsoft almacena los datos en archivos con extensión mdb, viene con la licencia de los productos de Office

-Microsoft SQL Server, es la DBMS profesional de Microsoft su licencia se vende aparte y funciona con los lenguajes .Net como Visual Basic, etc.

CONCEPTOS BASICOS DE LA TEORIA DE OBJETOS


INTRODUCCION

La teoría de objetos y específicamente la programación orientada a objetos la herramienta estándar para la programación de sistemas grandes y complejos, se contrapone a los métodos antiguos de programmación, especialmente los procedurales y aún la programación estructurada. Está fuertemente influenciada por la teoría de conjuntos y trata de temas como encapsulación, polimorfismo, clases, etc.

La OOP (programación orientada a objetos) no es muy intuitiva y abunda en conceptos formales y semánticos, lo que puede resultar desanimante para los que buscan conseguir un código elegante o particularmente ingenioso. Como la mayoría de las cosas complicadas, la OOP es extremadamente general en su esencia, el objetivo es que una vez dominado el lenguaje y la operatoria de objetos, el proceso de implementar un software sea tan fácil como transcribir un texto, la idea fundamental es eliminar al programador ingenioso.

Al hablar de OOP no nos referimos a ningún lenguaje en particular, pues se trata de un método y no de un lenguaje específico (tal como lo fué la programación estructurada en su época). Los lenguajes C++ y Java son los mas conspicuos entre los diseñados específicamente para cumplir los requisitos de la OOP, Visual Basic a partir de la versión .net incluye funcionalidades fundamentales de la OOP: herencia, encapsulación, polimorfismo y sobrecarga

Una de las principales ventajas de la OOP es la facilidad para heredar y reutilizar código. Esto no es nada nuevo y todo programador más o menos antiguo sabe usar el cut-and-paste de código, la diferencia es que la OOP promete, al menos en teoría, un método racional de reutilizar el código ya escrito para otros propósitos. En éste campo los métodos de la OOP si tienen sentido y utilidad para cualquiera. Es muy dudoso que sín este tipo de programación se hubiese conseguido hacer funcionar grandes sistemas como el Windows y su entorno.

EMPECEMOS CON LA TEORIA

¿Qué es un objeto?, un objeto es una cosa. Cualquier cosa y se usa ese concepto para dar la idea que los métodos de la OOP son aplicables sobre cualquier cosa en el ámbito de la programación (los origenes de estos conceptos están en la teoría de conjuntos, algo muy usado en estructura de datos y cosas así). Un objeto se caracteriza por ser algo muy general, algo tan general que puede ser cualquier cosa. En la OOP los objetos tienen

Datos (o características) y
Métodos (o comportamiento)

Una instancia es un caso particular de un objeto general, un objeto puede ser una instancia de una clase. Por ejemplo el objeto Mi_Edad puede tener la instancia 45 y puede pertenecer a la clase de los números enteros, dicho en código:

int Mi_Edad:=45

Si estamos programando en Java por ejemplo int es una clase que viene incluida en el lenguaje. Pero el programador también podría crear sus propias clases. Por ejemplo puedo crear una clase de ventanas que contenga las cajas de mensaje para mis programas, en código algo más o menos así

Marco CajaMensaje:= new Ventana()

Las clases int y marco son conceptualmente lo mismo, solo que una viene dada por el lenguaje y la otra la definimos nosotros mismos, así es como podemos enriquecer un lenguaje con nuestras propias clases.

Así tenemos que una CLASE un tipo particular de objetos, es una coleccion de objetos con sus datos y métodos correspondientes. Es similar a los conjuntos, subconjuntos y conjuntos de conjuntos. Solo cambian los nombres pero la idea es igual.

Hablando computacionalmente un objeto podemos pensarlo como un array (vector) de varias dimensiones, con datos y métodos. Los métodos son punteros que apuntan a funciones que trabajan con los datos.

LA HERENCIA

Ejemplo: supongamos que se programa una clase que lee números enteros ingresados por teclado, le calcula el IVA a cada número y lo graba. Ahora bien, supongamos que ahora deseo tener otro procedimiento que pueda hacer lo mismo con números reales.. En la programación tradicional se usaría el cut-and-paste cambiando lo que sea necesario, pero con OOP solo se necesita crear una nueva subclase, que heredará todos los métodos de la clase padre y solo necesita redefinir el método de lectura del teclado.

Y así vamos creando nuevas clases, heredando las antiguas y modificándolas según nos convenga. Las cualidades comunes a las distintas clases forman una superclase. Por ejemplo se puede hacer una superclase INVENTARIO de la cual se derivan las clases ventas, compras, ingresos nuevos, etc. La clase padre contiene los métodos comunes a las demás y solo hay que añadir los métodos que se necesiten al crear una nueva clase. Si una clase padre contiene el método IMPRIMIR por ejemplo, éste estará disponible para todas sus hijas

La herencia permite reutilizar todo el código escrito para las superclases, escribiendo solo las diferencias específicas que necesita la subclase. Al heredar, la subclase toma directamente todos los métodos de la superclase e indirectamente todos los de las clases superiores a ella en su rama

Se heredan los datos (características del objeto) y los métodos (el comportamiento). Usualmente son los métodos los que se modifican

Hay clases abstractas o virtuales que no hacen nada (no tienen métodos) y solo sirven para basar otras subclases, algo así como agruparlas bajo un mismo tipo

La subclase solo hereda componentes visibles desde su clase hija, y tiene forzosamente que redefinir alguno de los métodos de la clase padre (si no sería la misma).

Un método se puede sustituir completamente o solo modificar: al sustituir se conserva el mismo nombre y la clase hija queda con un método de igual nombre pero que se comporta de distinta manera que el de su padre.

Si en cambio solo modificamos un método heredado (es decir lo ampliamos), necesitará usar primero el método del padre (herencia) y después el del hijo. Como ambos se llaman igual hay que diferenciarlos usando el prefijo this (o self) para la clase hija y super para la clase padre

LA ENCAPSULACION

Un ejemplo práctico. Supongamos que defino la clase recuadro, para dibujar un cuadro an la pantalla, con los datos y métodos que se muestran a continuación:

DATOS                                 METODOS
(x,y) sup. izquierda             mostrar
(x,y) inferior derecha          ocultar
linea                                     mover
color de linea 
color de relleno 

Para dos recuadros podríamos tener los siguientes valores (por ejemplo)

DATOS (PROPIEDADES)     valores objeto 1     valores objeto 2
(x,y)sup. izquierda                     7,5                         14,50
(x,y) inferior derecha                 22,12                      20,60
linea                                           doble                      simple
color de linea                             verde                      verde
color de relleno                           azul                         rojo

Note como los datos (o propiedades) son los mismos para todos los objetos de la clase, sus valores son distintos, asi tenemos un cuadro azul en la punta superior izquierda de la pantalla y otro rojo en la punta inferior derecha

Los métodos harán lo obvio según el nombre:

* mostrar :muestra el cuadro
* ocultar oculta el cuadro
* mover mueve el cuadro a una nueva posición

Un método de una clase puede llamar a otros de su misma clase y cambiar sus valores. Todos los datos de una clase son privados y deben accederse mediante métodos públicos.

Privados, significa que solo pueden intercambiar informacion dentro de su mismo nivel, públicos pueden recibir valores desde otros niveles.

Por ejemplo para modificar la coordenada y1 (de (x,y) superior izquierda) podríamos hacerlo de dos maneras:

* asignandole directamente un valor desde afuera (por ej. RecuadroGeneral y1=12)
* invocándo un método, por ejemplo 'poner' RecuadroGeneral.Poner y1=12

El segundo método es el que se debe usar para mantener el principio de la encapsulación, que dice que una clase debe ser una estructura cerrada, solo se debe acceder a ella a través de los métodos definidos para ella y nada más

Si definimos la variable y1 del tipo publico (es decir que puede asignarsele valores desde cualquier punto del procedimiento, estaremos violando el principio de la Encapsulación

Para evitar estas asignaciones directas y crear clases 'encapsuladas' algunos datos se pueden definir de solo lectura o bien declararlos como variables privadas. Existe sin embargo una excepción a esta regla: se pueden hacer públicos los datos que la clase no utiliza.

Para que un método pueda actuar hay que mandarle un mensaje a la clase. Las clases son entonces como 'cajas negras' que ejecutan sus métodos cuando reciben un mensaje, manteniendo su operación interna cerrada e inaccesible desde el exterior.

POLIMORFISMO

El polimorfismo es la cualidad que tienen los objetos para responder de manera distinta ante el mismo mensaje. Por ejemplo si enviamos el mensaje IMPRIMIR a distintos objetos, cada uno hará algo distinto según lo que tengan definido como imprimir, así uno imprimirá a espacio simple otro a doble espacio, otro con distinto tipo de letra, etc.

El polimorfismo es consecuencia natural de que podemos sustituir los métodos, o sea dos objetos pueden tener los metodos de igual nombre pero actuarán de manera distinta según hayan sido definidos dentro de su clase.

La gran ventaja del polimorfismo es que n métodos con igual nombre cercanos a la raíz del arbol de clases, afectan a todas las clases hacia abajo.

SOBRECARGA

La sobrecarga consiste en que varios métodos pueden tener el mismo nombre, siempre y cuando el tipo o número de parametros que reciban sea diferente, por ejemplo, para la clase FILE definimos el método WRITE

FILE::WRITE(int i);
FILE::WRITE(long l);
FILE::WRITE(STRING EESO);

etc..

LA PRACTICA: CLASES EN VISUAL BASIC

Un ejemplo práctico, sencillo para principiantes es encapsular las funciones para hacer una ventana

El ejemplo de la ventana

Se trata de abrir un proyecto con un form al que se le agrega un módulo de clase, en el módulo de clase declaramos como Publica la variable estado y escribimos dos funciones privadas: abrir y cerrar

ventana.cls (módulo de clase)
Public estado as integer '1 abierta, 0 cerrada

Public Sub abrir()
    estado = 1
End Sub

Public Sub cerrar()
    estado = 0
End Sub

Luego en el Form_Load del formulario del mismo proyecto (Form1) escribimos lo siguiente:

FormVentana.frm (formulario)
Dim Ventana_salita As New ventana ' Creamos mi Ventana_salita

Ventana_salita.abrir 'Abramos la ventana de la salita
estado = Ventana_salita.estado 'comprobemos que efectivamente se ha abierto

Ventana_salita.cerrar 'Cerremos ahora la ventana
estado = Ventana_salita.estado


Y tenemos listo nuestro primer programa con módulos de clase, que no hace absolutamente nada, aparte de cambiar el valor de la variable estado. En realidad el programa es tan primitivo que para ver el efecto hay que poner breackpoints en cada línea del Form_Load y ver los valores de variable con el debug. La primera modificación que se puede ahcer es agregarle dos botones a la form (abrir y cerrar) y unas msgbox que mostraban el valor que iba tomando la variable 'estado'. En fin, no es muy interesante el ejemplo, así es que pasemos al siguiente: programar una clase para grabar y recuperar datos en archivos random.

Manejo de archivos random planos con módulos de clase

Primero que nada hice la interfase, colocando nombres significativos a los objetos (en lugar de usar los nombres por defecto) y usando la Option Explicit, que obliga a declarar todas las variables (buenas prácticas de programación). La cosa queda más o menos así:

Lo primero es insertar un módulo de clase que que llamaremos 'ArchivoPlano'

Enseguida se programan los métodos leer, grabar, agregar, listar (que corresponden a los botones de la form) y que no son más que funciones privadas

El módulo de clase, paso a paso 

Al principio de la clase declaramos las variables nombre, direccion y telefono como strings publicos (para leer la información desde el form)

También definímos las variables pos (la posición en que se graba un registro) y puntero (la posición del último registro, para agregar) como enteros

Luego definímos los campos Xnombre, Xdireccion y Xtelefono del archivo plano para esto se usan los tipos definidos por usuario con type... end type y luego un private dat as registro que le asigna esos campos como 'apellidos' de la variable dat

Enseguida vienen los métodos abrir(archivo), cerrar(archivo) e incrementa_puntero(archivo). Estos tres métodos son solo de uso interno, dentro de la misma clase como veremos más adelante.

Los dos primeros se explican por si mismos, incrementa_puntero merece alguna explicación. En este ejemplo reservamos el primer registro del archivo para guardar el puntero, que es un número que se incrementa en uno cada vez que agregamos un registro, también nos sirve para saber en que posición va la cola del archivo para agregar los registros nuevos. Lo primero que hace este método es llamar a otro método dentro de la clase que se llama lee_puntero, el cual a su vez llama al método abrir(archivo), lee el primer registro y almacena el valor de dat.Xnombre en la variable puntero, luego cierra el archivo.

Retornando el control a incrementa_puntero se vuelve a invocar abrir(archivo) y si el puntero tiene el valor cero, se cambia a uno, para asegurarse que el primer registro quedará en la pocisión 2 y no sobreescribirá el lugar donde se guarda el puntero. Luego se incrementa el puntero en uno y se vuelve a grabar en la primera pocisión del archivo usando el campo Xnombre

Creo que si se ha entendido hasta ahora las demás rutinas ya no necesitan explicación

ArchivoPlano.cls (módulo de clase)
Public nombre, direccion, telefono As String
Public pos, puntero As Integer

Private Type registro
    Xnombre As String * 30
    Xdireccion As String * 30
    Xtelefono As String * 20
End Type

Private dat As registro

Public Sub abrir(archivo)
    cerrar
    Open archivo For Random As 1
End Sub

Public Sub cerrar()
    Close
End Sub

Public Sub lee_puntero()
    abrir (archivo)
    Get 1, 1, dat
    puntero = Val(dat.Xnombre)
    cerrar
End Sub

Public Sub incrementa_puntero()
    lee_puntero
    abrir archivo
    If puntero = 0 Then
        puntero = 1
    end if
    puntero = puntero + 1
    dat.Xnombre = puntero
    Put 1, 1, dat
    cerrar
End Sub

Public Sub leer(archivo, pos)
    abrir (archivo)
    Get 1, pos, dat
    nombre = dat.Xnombre
    direccion = dat.Xdireccion
    telefono = dat.Xtelefono
    cerrar
End Sub

Public Sub grabar(archivo, pos)
    abrir (archivo)
    dat.Xnombre = nombre
    dat.Xdireccion = direccion
    dat.Xtelefono = telefono
    Put 1, pos, dat
    cerrar
End Sub

Public Sub agregar(archivo)
    incrementa_puntero
    abrir (archivo)
    dat.Xnombre = nombre
    dat.Xdireccion = direccion
    dat.Xtelefono = telefono
    Put 1, puntero, dat
    cerrar
End Sub

El código del form

Programada la clase pasamos a programar nuestra form, Aquí no voy a entrar en explicaciones porque creo que basta con mirar el código, reproducirlo y analizarlo queda así:

FormArchivo.frm

Private Sub agregar_Click()
    ArchivoPlano_mio.nombre = BoxNombre.Text
    ArchivoPlano_mio.direccion = BoxDireccion.Text
    ArchivoPlano_mio.telefono = BoxTelefono.Text
    ArchivoPlano_mio.agregar archivo
    BoxPosicion.Text = ArchivoPlano_mio.pos
End Sub

Private Sub grabar_Click()
    Xpos = Val(BoxPosicion.Text)
    ArchivoPlano_mio.nombre = BoxNombre.Text
    ArchivoPlano_mio.direccion = BoxDireccion.Text
    ArchivoPlano_mio.telefono = BoxTelefono.Text
    ArchivoPlano_mio.grabar archivo, Xpos
End Sub

Private Sub leer_Click()
    Xpos = Val(BoxPosicion.Text)
    ArchivoPlano_mio.leer archivo, Xpos
    BoxNombre.Text = ArchivoPlano_mio.nombre
    BoxDireccion.Text = ArchivoPlano_mio.direccion
    BoxTelefono.Text = ArchivoPlano_mio.telefono
End Sub

Private Sub Boxlistar_Click()
    List1.Clear
    ArchivoPlano_mio.lee_puntero
    For z% = 2 To Ventana_mia.puntero
        Ventana_mia.leer archivo, z%
       List1.AddItem ArchivoPlano_mio.nombre & Chr(9) & ArchivoPlano_mio.direccion & Chr$(9) & ArchivoPlano_mio.telefono
    Next z%
End Sub


Y el módulo de declaraciones globales

Para no tener que estar repitiendo en todos lados la declaración de la clase y el nombre del archivo, pueden colocarse en un módulo así

ModGlobales.bas

Option Explicit
Public ArchivoPlano_mio As New ArchivoPlano
Public Const archivo = "prueba"

CONCLUSIONES

La OOP es, en gran medida un esfuerzo linguistico, el mismo viejo código con nuevas normas (bastante buenas cuando codificamos sistemas complejos): las clases son herederas de los tipos definidos de usuario (así como esos del Type....End Type que colocaban 'apellido' a las variables), de las funciones y aún de las subrutinas del viejo GWBasic. Muchos años atrás los programadores se fueron dando cuenta que era conveniente hacer un stock de subrutinas y funciones genéricas para echar mano siempre, cambiándo solo los argumentos. La OOP es principalmente la formalización de ese concepto.

Una diferencia importante con el viejo estilo de programación es que todas las variables que se usan al interior de una clase son privadas, lo que las hace actuar como una caja negra de código.

Para los que hemos estado expuestos al Visual Basic tenemos bastante avanzado en la terminología de los objetos, que es la principal dificultad del asunto. En Visual Basic tenemos controles con propiedades, métodos y eventos. Un CommandButton por ejemplo tiene la propiedad Caption (Command1.caption="Ok"), el método Setfocus (Command1.Setfocus) y el evento click (Private sub Command1_Click... etc..) .por lo que ya tenemos infiltrados intuitivamente algunos conocimientos importantes. Sumando y restando, los conceptos de la OOP son muy convenientes aplicados sobre proyectos complejos. En proyectos pequeños y aplicaciones del lado cliente está Ok, siempre que se tome como una guía y no como una biblia inflexible

Comentarios

Tomas Bradanovic
Tomas Bradanovic
far niente en BGL
Arica, Chile
Calif. artículo:
Tu calificación:
Versión:11
Versiones
Última modificación: 20/05/2009 00:35.

Categorías

Actividad de este knol

Esta semana:

41visitas a la página

Totales:

817visitas a la página