Post on 08-Nov-2018
transcript
Casa abierta al tiempo UNIVERSIDAD AUTONOMA METROPOLITANA f-
DIVISI~N DE CIENCIAS BASICAS E INGENIERÍA
DEPARTAMENTO DE INGENIERIA ELECTRICA
Diseño y desarrollo de un paquete de computación multimedia con el
uso agregado de servicios TCP/IP (Internet) para la impartición de la
UEA de Comunicaciones I de la carrera de Ingeniería Electrónica.
Que presentan los alumnos:
López Cruz Raymundo.
López Baez Manuel.
Para obtener el grado de:
Licenciatura en Ingeniería Electrónica
Asesor de Proyecto:
Ing. Miguel Angel Gutiérrez Galindo. n
Julio del 2001
INDICE
2 2 5 8 9 5 PORTADA .................................. .......................................................................................... 1
INDICE 11
INTRODUCCION ................................................................................................................ iv
1 . DISENO DEL SITIO WEB .............................................................................................. 1
1 . 1. INTRODUCCION ............................................................................................. 1
1.2. DIRECTIVAS HTML ....................................................................................... 1
1.3. JAVASCRIPT .................................................................................................... 9
.. .................................................................................................................................
.
1.4.UTILIZACIÓN DEL PROGRAMA MICROSOFT FRONT PAGE ................ 14
1.5. BASES DE DATOS EN LA WEB UTILIZANDO ADO Y ASP ................... 18
1 .5 . 1 . INTRODUCCION ............................................................................. 18
1.5.2. REQUISITOS .................................................................................... 18
1.5.3. TERMINOLOGÍA ............................................................................. 19
1.5.4. OBTENER UN DNS ......................................................................... 19
1.5.5. DECLARACION DEL FORMULARIO .......................................... 19
1.5.6. LOS OBJETOS COMPONENTES DE ADO ................................... 20
1.5.7. CREACIóN DE COMPONENTES ACTIVEX SERVER .............. 27
1.6. ESTRUCTURA BÁSICA DEL SITIO WEB .................................................. 31
1.7. CONSTRUCCION UNA PAGINA ASP ......................................................... 37
1.7.1 . MODELO DE ANALISIS DE REQUERIMIENTOS ...................... 37
1.7.2. MODELO DE ANALISIS DINÁMICO ........................................... 40
2 . DISEÑO DE LOS PROGRAMAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
2 . 1 . ESTUDIO DEL LENGUAJE DE PROGRAMACIóN C++ .......................... 42
2.2. ALGORITMOS MÁS ~JSADOS ..................................................................... 44
2.2. 1 . GRAMÁTICA PARA VALIDAR FUNCIONES ............................. 48
2.2.2. D E F I N I C I ~ N DE LA GRAMÁTICA PARA HACER LA
V A L I D A C I ~ N UNA E C U A C I ~ N DE ENTRADA .................................. 52
2.3. PRINCIPIOS PARA EL ANALISIS Y DISEÑO ORIENTADO A OBJETOS
.................................................................................................................................. 54
2.4. PROGRAMA MINIMOS CUADRADOS ....................................................... 63
2.4. 1 . DESCRIPCIóN DEL PROBLEMA ................................................. 63
2.4.2. MODELO DE ANALISIS DE REQUERIMIENTOS ...................... 64
2.4.3. MODELO DE ANALISIS DINAMICO ........................................... 73
2.5. PROGRAMA SERIES DE FOURIER ............................................................. 80
2.5. 1 . DESCRIPCIóN DEL PROBLEMA ................................................. 80
2.5.2. MODELO DE ANALISIS DE REQUERIMIENTOS ...................... 80
2.5.3. MODELO DE ANALISIS DINAMICO ........................................... 85
3 . DISEÑO DE AYUDAS .................................................................................................. 89
4 . CREACIóN DE UN DOCUMENTO EN ADOBE ACROBAT ................................... 94
5 . INTEGRACI~N FINAL DEL SITIO WEB ................................................................... 100
BIBLIOGRAFÍA ............................................................................................................... 109
CONCLUSIONES ............................................................................................................ 107
... I l l
INTRODUCCION
En el mundo en que vivimos es muy importante la educación universitaria, ya que en su
seno se formarán los futuros profesionistas y empresarios que definirán el porvenir
económico y social de nuestro país, por ello creemos importante explorar y explotar todos
los medios posibles para hacer llegar cursos impartidos en la universidad a los alumnos, y
además, hacerlo bajo un enfoque real, de alta calidad y acorde a nuestra era moderna.
Bajo esta perspectiva, se optó por la creación de un curso especial de
Comunicaciones I en un sitio Web tratando de utilizar una gran variedad de utilerías para
hacer el sitio muy flexible, dinámico y lo más completo posible para su consulta y uso,
además de apoyar didácticamente a los temas más importantes con ayuda de programas de
computo para su descarga y posterior uso.
Este curso y sus utilerías asociadas se pensaron para construirse bajo una perspectiva
orientada a objetos, ya que actualmente es el modelo de construcción más utilizado por los
diseñadores de sistemas en todo el mundo, siendo la notación LJML una de sus
herramientas de diseíio y análisis más importantes.
En las paginas subsecuentes haremos una breve revisión de los conceptos más
importantes y útiles para la construcción de nuestro sitio y algunos detalles importantes
acerca de la construcción del sitio y de las utilerías adicionales.
iv
1. DISEÑO DEL SITIO WEB.
1 1.1. INTRODUCCION
La perspectiva global del proyecto nos demostró la necesidad de estudiar el lenguaje
HTML para tener una idea clara de los alcances de una página en Internet, siendo muy
necesario ya que existe software que convierte texto a formato HTML pero no siempre
obtenemos una presentación adecuada, por lo que hay que ver el código y hacer las
modificaciones necesarias.
Para el aprendizaje de HTML se estudió en libros y sitios Web que ofrecían tutoriales
de HTML. Podemos decir que la mejor herramienta fueron los tutoriales vía Internet ya que
son herramientas interactivas en donde el usuario puede ver los resultados de cada comando
de manera inmediata, mientras que en un libro es necesario escribir todo el código para
poder ver los resultados. Enseguida se presenta un resumen sobre HTML con las directivas
más usadas en el sitio Web. Por último mencionaremos que HTML es el lenguaje de
programación más extendido para la construcción de sitios Web.
1 1.2. DIRECTIVAS HTML
Durante el desarrollo del proyecto, se han logrado comprender muchos de los conceptos
útiles de HTML (HyperText Markup Language) que son necesarios para el desarrollo de
nuestro paquete multimedia, y que sin los cuales, su desarrollo orientado al uso agregado de
servicios TCP/IP sería muy complicado. A continuación mencionaremos algunos de los
conceptos más importantes de HTML, que son útiles para el buen desarrollo de nuestro
paquete de cómputo.
En primer lugar, uno de los conceptos básicos es que HTML es un lenguaje simple
de indicación de formato utilizado para crear documentos en hipertexto que son portables
de una plataforma a otra, es decir, es un lenguaje utilizado para representar documentos en
la WWW (World Wide Web). Los documentos HTML son documentos con semántica
genérica, apropiados para representar información a partir de un amplio espectro de
aplicaciones. Esto significa, que un documento elaborado en HTML será reconocido casi
en cualquier máquina, en cualquier parte del mundo, con ayuda de un navegador, sin
importar el sistema operativo de la máquina (software) ni la arquitectura de la misma
(hardware). Esta característica de HTML es muy importante, ya que nuestro paquete de
cómputo tomará también la característica de portabilidad, por lo que podrá ser leído y
ejecutado desde cualquier parte del mundo.
Dentro de las características importantes del lenguaje HTML tenemos que este
lenguaje se basa en el uso de etiquetas (tags), que se diferencian del texto regular con un
par de paréntesis angulares(<..>), es decir, todo el lenguaje está basado en el uso de los
tags. Pero debido a ello HTML basa su codificación en simbolos ASCII.
La estructura fundamental de un documento HTML está definido por una etiqueta de
apertura <HTML> y una etiqueta de cierre </HTML>, dentro de este se dividen dos partes
fundamentales: la cabecera, delimitada por la etiqueta <HEAD> y el cuerpo, delimitado
por la etiqueta <BODY>. Ellas constituyen así las tres características más importantes de
un documento HTML. Ejemplo:
</HEAD> <BODY> //Conjunto de directivas HTML correspondientes al documento. </BODY> </HTML
Dentro de los documentos HTML podemos tener todo tipo de estructuras de
información, por ejemplo, podemos tener texto de distinto tamaño, tipo de letra, y asimismo
podemos incluir tablas de consulta, listas, imágenes e hiperenlaces con otras páginas
importantes. Las directivas para hacer este tipo de presentaciones son:
1
La directiva <PRE></PRE> obliga al visor o navegador a visualizar el texto tal y
como ha sido escrito, respetando tabulaciones, espacios, retornos de carro, etc.
Para indicar un salto de línea se utiliza la directiva <BR> y para un cambio de
párrafo (deja una línea en blanco en medio) se utiliza la directiva <P>.
0 La directiva <P> puede usarse también como directiva "cerrada'l <P></P>
indicando de esta manera los atributos de un párrafo en concreto. Cuando se usa de
esta manera tiene el parámetro align que indica al visor la forma de "justificar" el
párrafo. Los valores posibles de este parámetro son LEFT, RIGHT y CENTER.
0 En un documento de HTML se pueden indicar seis tipos de cabeceras (tamaños de
letra) por medio de las directivas <Hl><H2><H3><H4><H5> y <H6>. El texto
que escribamos entre el inicio y el fin de la directiva será el afectado por las
cabeceras. La cabecera <H1> será la que muestre el texto en mayor tamaño.
0 La directiva <FONT></FONT> nos permite variar el tamaño, el color, y el tipo
de letra de un texto determinado. Utiliza para ello los parámetros size, bgcolor y
face.
Para incluir comentarios en la página Web se utiliza la directiva <!-- -->
0 Existen tres tipos de listas: numeradas, sin numerar y de definición. Las listas
numeradas representarán los elementos de la lista numerando cada uno de ellos
según el lugar que ocupan en la lista. Para este tipo de lista se utiliza la directiva
<OL></OL>. Cada uno de los elementos de la lista irá precedido de la directiva
<LI>. La directiva <OL> puede llevar parámetros.
Las listas sin numerar representan los elementos de la lista con un "topo" o marca
que antecede a cada uno de ellos. Se utiliza la directiva <UL></UL> para
delimitar la lista, y <LI> para indicar cada uno de los elementos. La directiva
<UL> puede contener el parámetro type que indica la forma del 'ltopo'' o marca
que antecede a cada elemento de la lista.
0 Las listas de definición muestran los elementos tipo "diccionario", o sea, término y
definición. Se utiliza para ellas la directiva <DL></DL>. El elemento marcado
como término se antecede de la directiva <DT>, el marcado como definición se
antecede de la directiva <DD>.
0 La lista de Menú utiliza la directiva <MENU></MENU> y los elementos se
anteceden de <LI> El resultado es una lista sin numerar mas "compacta" es decir,
con menos espacio interlineal entre los elementos. La lista de Directorio utiliza la
directiva <DIR></DIR> y los elementos se anteceden de <LI>. Los elementos
tienen un límite de 20 carácteres.
Para incluir una imagen en nuestra página Web utilizaremos la directiva <IMG>.
Hay dos formatos de imágenes que todos los navegadores modernos reconocen:
las imágenes GIF y JPG. Cualquier otro tipo de fichero gráfico o de imagen
(BMP, PCX, CDR, etc.) no será mostrado por el visor, a no ser que disponga de un
programa externo que permita su visualización
0 La característica principal de una página Web es que podemos incluir
hiperenlaces. Un hiperenlace es un elemento de la página que hace que el
navegador acceda a otro recurso, otra página Web, un archivo, etc. Para incluir un
hiperenlace se utiliza la directiva <A></A>. El texto o imagen que se encuentre
dentro de los límites de esta directiva será sensible, esto quiere decir que si
pulsamos con el ratón sobre él, se realzará la función de hiperenlace indicada por
la directiva <A></A>. Si el hiperenlace esta indicado por un texto, este aparecerá
subrayado y en distinto color, si se trata de una imagen, ésta aparecerá con un
borde rodeándola. Esta directiva tiene el parámetro href, que indica el lugar a
donde nos llevará el hiperenlace si lo pulsamos
Las tablas nos permiten representar cualquier elemento de nuestra página (texto,
listas, imágenes, etc.) en diferentes filas y columnas separadas entre sí. Es una
herramienta muy útil para ''ordenar'' contenidos de distintas partes de nuestra
página. La tabla se define mediante la directiva <TABLE></TABLE>.
Además de estas, existen aplicaciones interesantes para una presentación agradable
del documento, por ejemplo, podemos tener una marquesina dentro del
documento.
La directiva <MARQUEE></MARQUEE> crea una marquesina con un texto en
su interior que se desplaza. Funciona únicamente con Ms-Explorer. Sus
parámetros son los siguientes: align = top / middle / bottom, indica si el texto del
interior de la marquesina se alinea en la zona alta (top), en la baja (bottom) o en el
centro (middle) de la misma. bgcolor = "código de color", indica el color del
fondo de la marquesina. direction = left / right, indica hacia que lugar se desplaza
el texto, hacia la izquierda (left) o hacia la derecha (right). height = num o %,
indica la altura de la marquesina en puntos o porcentaje en función de la ventana
del visor. width = nurn o YO, indica la anchura de la marquesina en puntos o
porcentaje en función de la ventana del visor. loop = num / infinite, indica el
número de veces que se desplazará el texto por la marquesina. Si se indica infinite,
se desplazará indefinidamente. scrolldelay = num, indica el número de
milisegundos que tarda en reescribirse el texto por la marquesina, un número
mayor significa que más lentamente se desplazará el texto.
Nuestra página Web puede tener un sonido que se active al entrar en la página. Esta
característica de Ms Explorer utiliza la directiva <BGSOUND> y tiene los siguientes
parámetros: src = flficheroll, indica el nombre del fichero que contiene el sonido (.waw,
.mid). loop = nurn / infinite, indica el número de veces que se reproducirá el sonido. Si se
indica infinite, el sonido se reproducirá de forma continua hasta que abandonemos la página
E incluso podemos incluir animaciones con formato GIF sencillas (GIF animado).
Un GIF animado es un gráfico del tipo GIF 89a que da la impresión de animación. Para
conseguir este efecto se deben crear por separado los gráficos GIF que componen la
secuencia de la animación. Una vez hecho esto utilizaremos un programa para 'Yundir"
todos estos gráficos en uno solo. Al mostrar este gráfico en nuestra página Web, el visor
mostrará la secuencia de todos los gráficos individuales de forma continua, con lo que dará
el aspecto de animación que buscamos.
También se podrían incluir mapas, donde un mapa es una imagen que permite
realizar diferentes hiperenlaces en función de la "zona" de la imagen que se pulse.
0 Las directivas para crear los mapas son <MAP></MAP> y <AREA>. Un mapa es
una imagen que permite realizar diferentes hiperenlaces en función de la ''zona'' de
la imagen que se pulse. La directiva <MAP> identifica al mapa y tiene el
parámetro name para indicar el nombre del mapa. La directiva <AREA> define
las áreas sensibles de la imagen. Tiene los siguientes parámetros obligatorios:
shape = "tipo", indica el tipo de área a definir. coords = "coordenadas" ,indica las
coordenadas de la figura indicada con shape. href = "URL", indica la dirección a
la que se accede si se pulsa en la zona delimitada por el área indicada
En cuanto al estudio que se ha hecho sobre Java, se ha encontrado la forma de agregar
animación a las páginas que se han diseñado, para poder tener una mejor presentación en
las mismas, un ejemplo de ésto son los applets que son programas que se incluyen en el
directorio en el que se encuentran nuestros documentos HTML, estos programas pueden ser
variados y pueden tener diferentes efectos en nuestro documento HTML, por ejemplo:
Un applet puede hacer que un texto en la página Web presente movimiento, este
movimiento puede cambiar de acuerdo a los parámetros que se le mande al programa
(applet), los parámetros de entrada se escriben dentro del código HTML, los movimientos
que se pueden tener pueden ser desplazamientos hacia la izquierda, hacia la derecha,
ondulatorios, o aleatorios entre otros.
Otros efectos que se observan son que también se pueden tener cambios en los
colores del texto, ya sea que sigan alguna secuencia determinada o que cambien
aleatoriamente.
Java es un lenguaje creado por Sun Microsystems que permite realizar operaciones
multimedia y animación en una página Web sin incorporar nuevas directivas HTML. Los
applets son muy variados, y cada uno de ellos realiza una tarea distinta. Hay applets para
hacer que el texto se mueva dentro de la hoja, se contraiga y expanda, etc. Esta directiva
tiene los siguientes parámetros: codebase = URL, dirección donde se encuentra el applet
Java (Por ejemplo http://www. ucm.es/java). Si el Applet se encuentra en el mismo lugar
que la página Web este parámetro no es necesario. code = programa, indica el nombre del
programa (applet) Java a ejecutar. width = num y height = num, indican el espacio (ancho
y alto) en puntos en el que el programa realizará su función. Dentro de la directiva
<APPLET> se incluye la directiva <PARAM> que envía al programa Java los parámetros
necesarios para su funcionamiento. Esta directiva suele tener como mínimo los parámetros :
name = campo, nombre de la variable a enviar. value = valor, valor de la variable a enviar.
Otra forma de animar las páginas Web es utilizando código JavaScript escrito
directamente en las mismas, es decir, ya no se tiene que incluir algún programa en el
subdirectorio que corresponda, ahora las instrucciones se escriben dentro del código
HTML, para indicarle al intérprete (navegador) que se tratan de funciones las cuales se
llamarán cuando sea necesario, se tienen que utilizar las directivas <SCRIPT> y
</SCRIPT> que indican al navegador que se trata de la definición de las funciones, al
momento de la llamada de las funciones se tiene que dar paso de parámetros como si se
tratara de un cornpilador, aunque en realidad esto no es una compilación, el paso de
parámetros depende de cómo estén definidas nuestras funciones, es decir, si las funciones
lo requieren.
Este tipo de animación de páginas tiene sus desventajas, una de ellas es que se ha
visto que algunos navegadores no tienen soporte para JavaScript o para applets escritos en
Java, por ejemplo se investigó y se vió que Internet Explorer V.4 no tiene soporte para
Java, sin embargo la versión 5 ya soporta este tipo de código, al igual que Netscape
versiones superiores a la 4.0.
Otra dificultad a la que nos enfrentamos es que no hay estándares definidos en los
diferentes navegadores, es decir, los navegadores de Microsoft interpretan el código de
cierta forma, mientras que Netscape en algunos casos interpreta de diferente forma el
código, con esto, tenemos que encontrar la forma de minimizar los posibles errores que se
puedan presentar al navegar por estas páginas, un ejemplo claro de ésto es el siguiente:
Cuando la página contiene texto, muchas palabras van acentuadas, por ejemplo, la
palabra "página" tiene la letra á acentuada, algunos navegadores presentarán esta palabra
7
sin ningún problema, mientras que otros no lo harán en forma correcta, para eliminar este
problema se utiliza el equivalente de la letra á, es decir todos los navegadores pueden leer
un equivalente de los caracteres especiales, dentro del código se puede escribir lo siguiente:
Página Página Página
Estas tres palabras son equivalentes para los navegadores en general.
Se ha visto que en un futuro estos problemas ya no existirán ya que se están
estandarizando los programas navegadores, conforme se tienen nuevas versiones de los
mismos se tienen menos diferencias en cuanto a la interpretación del código, esto
representa una ventaja para la edición de páginas Web en el futuro.
Una aplicación parecida a los applets es el Script. Un Script es un programa escrito en
un lenguaje distinto al HTML que se puede incluir en una página Web "tal cual". Para
incluir estos programas en una página Web se utiliza la directiva <SCRIPT> </SCRIPT>.
Esta directiva tiene el parámetro language para indicar el lenguaje de programación
utilizado para el Script. El código del programa debe "ocultarse1' con las directivas de
comentario de HTML <!-- --> con el objeto de que no sean mostradas por los visores que
no reconocen la directiva <SCRIPT>. Los scripts más usados suelen estar escritos en
lenguaje JavaScript. Asimismo se podrán incluir con esta directiva programas escritos en
C++, Per1 o Visual Basic.
Ya que el tiempo es relativamente corto, se tienen alternativas para incluir Scripts en
nuestro documento, por ejemplo, si estamos viendo una página que tiene algún efecto
especial que nos guste, simplemente hemos de visualizar el código fuente de la misma (en
Netscape opcion View - Document Source), marcar con el ratón todo el bloque contenido
entre las directivas <SCRIPT> </SCRIPT>, copiarlas al portapapeles con CTRL+C y
posteriormente incluir este bloque en nuestra página modificando los literales o frases
animadas. Estas frases serán fáciles de localizar porque contendrán la palabra var xx= "
..... "antecediéndolas.
Otra aplicación interesante, son las frames. Las frames es una técnica para subdividir
la pantalla del visor en diferentes ventanas. Cada una de estas ventanas se podrá manipular
por separado, permitiéndonos mostrar en cada una de ellas una página Web diferente. Esto
es muy útil, por e-jemplo, para mostrar permanentemente en una ventana los diferentes
contenidos de nuestra página, y en otra ventana mostrar el contenido seleccionado. En
principio definir un "frame1' es muy sencillo, basta definir por medio de la directiva
<FRAMESET>, sustituyendo a la sección <BODY>. En esta directiva se especifican las
áreas y tamaños por medio de los atributos COLS y ROWS. Para definir el contenido de
cada "frame" utilizaremos la etiqueta <FRAME SRC="DOCUMENTO.HTML">, con lo
que asociamos a un frame determinado ese documento HTML.
En segundo lugar, hemos podido tener acceso a paquetería extra para desarrollar
adecuadamente nuestro proyecto, por ejemplo, los programas editores de HTML, que hacen
más fácil la colocación de directivas propias del lenguaje, y que además, nos permite ver
una presentación preliminar de nuestras páginas, logrando corregir errores de una manera
rápida y sencilla. Con esto ahorramos tiempo y podemos mejorar aún más la presentación
del curso.
Hasta ahora hemos llegado ya a un punto en que tenemos la capacidad de entender
como están hechas las páginas en cuanto al código HTML, sin embargo, no sólo usamos
HTML, también fue necesario utilizar JavaScript para mejorar la presentación de las
páginas, por ello enseguida se presenta un resumen con lo más utilizado de JavaScript.
1 1.3. ,JAVASCRIPT
Para el desarrollo de las páginas Web contenidas en nuestro sitio fue necesario tener
conocimientos sobre JavaScript, este lenguaje se utilizó, por ejemplo, para desarrollar el
menú de la página con Frames, o para poder realizar la página de calificaciones, aunque en
esta también se utilizó VBScript. Enseguida se presenta un resumen sobre JavaScript con
los comandos y funciones más comunes del lenguaje que se utilizaron en el desarrollo de
las páginas.
9
Las directivas de JavaScript están contenidas en un documento HTML, como se vió
anteriormente en la sección de HTML, para insertar código JavaScript en el documento
HTML se deben agregar las directivas <SCRIPT> para señalar el inicio de nuestro código y
</SCRIPT> para señalar el final de nuestro código, el parámetro necesario para esta
directiva es: lenguaje="javascript". De hecho el código JavaScript produce código HTML,
pero trabajar solamente con JavaScript sería muy complicado, por eso para poder elaborar
un documento completo sin mayores dificultades se puede trabajar con HTML y JavaScript
en combinación.
Para el estudio de JavaScript es necesario tener conocimientos de HTML ya que
JavaScript utiliza forzosamente la directiva FORM de HTML, JavaScript extiende la
funcionalidad de HTML y es también un puente entre Java, el navegador y HTML,
permitiendo la manipulación de navegadores y los componentes del documento, los
programas de JavaScript no funcionan si no se encuentran en un documento HTML, para
poder ver los efectos del código JavaScript en el documento HTML es necesario tener
instalado un navegador que soporte programas de JavaScript, de lo contrario el diseñador
debe dar, en la página, un aviso al usuario sobre la no-funcionalidad de JavaScript en su
Navegador.
Los programas de JavaScript típicamente son localizados en el encabezado de un
documento HTML, <HEAD>, es decir, tanto las funciones como las inicializaciones
necesarias deben estar contenidas en el encabezado para que el navegador los procese antes
de mostrar la página, enseguida se muestra un ejemplo de como se debe hacer esto:
<HTML> <HEAD> <TITLE>Documento con JavaScript</TITLE> <SCRIPT lunguaje= "JavaScript "> < !- //El cuerpo de los programas en java van aquí. Final del código JavaScript -> </HEAD> <BODY> Directivas HTML y llamada de las funciones JavaScript </BODY> </HTML
Los programas en JavaScript pueden usar tres mecanismos para generar salidas:
abriendo nuevas ventanas del browser, mostrando mensajes ya sea de error, confirmación o
de cuidado, y generando texto HTML para que el navegador lo muestre en el documento.
Las anteriores formas de producir tales salidas se conocen como formas directas, sin
embargo existe otra forma llamada forma indirecta, que consiste en la manipulación de los
objetos del navegador.
Enseguida se presenta un resumen con las principales funciones de JavaScript.
0 Las funciones en JavaScript se declaran de la siguiente manera:
regreso function suma(parámetros) {
regreso es el valor que la función regresará y puede ser de diferentes tipos:
Variables.
Las variables en JavaScript son localidades de memoria que el sistema operativo
aparta para poder ejecutar correctamente el programa escrito, estas se declaran con el
comando var. Dichas variables pueden tener como nombre un conjunto de caracteres y
números como sigue.
a sensor34z hola
as -
numero uno -
Ejemplos de nombres ilegales para variables son los siguientes:
12hola $uno contador% variable dos
Tipos de datos y valores.
Byte Int
Byte Entero
I Float I Flotante I String
Boleano Boolean Cadena de caracteres
Corn
I Double I Double
landos para ciclos.
while
break continue if else switch in
for
La sintaxis para los anteriores comandos es la misma que para el lenguaje de
programación C.
Objetos.
JavaScript es un lenguaje orientado a objetos, es decir se pueden aplicar todos los
conceptos de objetos que se usan para cualquier lenguaje, para referirse a un objeto se
pueden utilizar las siguientes sentencias:
this with new
Existen diferentes objetos visuales que nos sirven como entradas para nuestro
documento HTML, estos objetos los podemos insertar con el comando input, dicho
comando necesita un parámetro el cual es: type, este parámetro tiene los siguientes valores.
0 Text: este comando crea un cuadro de texto de una sola línea.
0 Password: Crea un cuadro de texto para ingresar un password, el texto que se
ingrese se visualizará solo con el carácter *.
Checkbox: Este tipo de entrada permite al usuario hacer una selección binaria no
exclusiva, en otras palabras, el usuario puede seleccionar una, varias o todas las
preguntas que se le haga, (normalmente si o no).
Radio: Esta permite al usuario hacer una selección exclusiva, en otras palabras, el
usuario puede escoger solo una de las preguntas.
Hidden: Este tipo de entrada es no interactivo ya que este simplemente coloca
valores numéricos que el usuario no puede modificar, solo puede elegir de entre
ellos.
0 Button: Este tipo crea un botón que genera un evento al darle un click, su
propiedad value determina el texto que se visualizará en el botón.
0 Reset: Este tipo es muy parecido al tipo button solo que cuando se genera su
evento click este coloca todos los elementos de entrada de todas las formas en sus
valores de default.
0 Submit: El tipo submit es muy parecido al tipo button, excepto que cuando se
genera su evento click envía la forma a la dirección URL que se asigne a la
propiedad action de la forma.
Aquí se han presentado las directivas más usadas en el sitio Web, con este resumen es
fácil entender como fué desarrollado el sitio. Cabe señalar que existe software el cual ya
inserta en el documento HTML código JavaScript, un ejemplo de ello es el programa
Microsoft Front Page. El cual contiene algunos programas ya desarrollados que se pueden
agregar a las páginas, por lo mismo se utilizó dicho software para la construcción de las
páginas.
1.4. UTILIZACIóN DEL PROGRAMA
MICROSOFT FRONT PAGE
Al momento de iniciar con el desarrollo de las páginas ya se tenían los conocimientos
básicos de HTML y JavaScript, también se había diseñado ya la estructura del sitio Web,
por lo cual sólo había que aprender a utilizar el software de manera adecuada, lo cual no fue
difícil ya que dicho software pertenece a la familia de Microsoft Office la cual se había
utilizado con anterioridad.
Para editar una página HTML primero se editaba el documento *.doc en Microsoft
Word, después se guardaba en formato HTML en un subdirectorio especial ya que todas las
imagenes y ecuaciones se guardan aparte, dicho subdirectorio se crea en Front Page para
poder abrir el documento HTML desde Front Page, si se mueve el documento de lugar las
modificaciones de los enlaces que contenga los realiza Front Page automáticamente.
Una vez editado el documento en el editor de Front Page, se le puede hacer cualquier
tipo de modificación para darle formato, todas las imágenes que contenga el documento no
están alineadas como uno quisiera, se pueden alinear si seleccionamos la imagen y con el
botón derecho del ratón vemos sus propiedades y en la opción seleccionamos medio
absoluta, este procedimiento se tiene que hacer para cada una de las imágenes, aplicando
nuestros conocimientos de HTML se puede hacer lo siguiente: vemos el código del
documento y sustituimos la directiva WIDTH= ” por ALIGN=”absmiddle” WIDTH=”, ya
que solo las imágenes contienen la directiva width, con esto todas las imágenes quedan
alineadas con una sola instrucción, aquí se ve la importancia que tiene haber estudiado
primero HTML.
Un problema que se encontró en la edición de documentos HTML, es que el código
JavaScript no era bien interpretado por Netscape, por lo cual se efectuó lo siguiente:
Primero se visualiza el código del documento, se localiza la parte del código
JavaScript y se analiza, normalmente el problema se presentaba porque el código
JavaScript se encontraba en el encabezado del documento, y se vio que Internet Explorer
primero ejecuta el código que se encuentra en el encabezado y después el cuerpo del
documento, Netscape no hace lo mismo, en dicho navegador se va mostrando el documento
y el código que se encuentra en el encabezado no lo reconoce, por lo mismo se tenía que
mover de lugar el código JavaScript, el lugar adecuado es al inicio del cuerpo del
documento.
Para generar un enlace a otra página con Front Page solo se tienen que seguir los
siguientes pasos.
0 Seleccionar el texto que nos servirá de enlace.
0 Oprimir la combinación Ctrl+D.
o Seleccionar, de la ventana que se muestra, el documento a vincular.
La siguiente ventana corresponde a Front Page, con ella se crea un enlace.
I Nombre I Título l’? Temario.html Contenido del Curso _1 -private _1 images -J Nueva-carpeta _1 Unidadl-1 _1 Unidadl-2 1 Unidadll-4 _I Unidadl-3 -J Unidad-4
m Cancelar I Estilo ... I Ayuda I
Ya que el sitio consiste de tres Frames (ver siguiente figura), se tenía que ver que al
abrir un documento se mostrará este en el frame principal, esto se hacía de la siguiente
manera:
Frame donnativo ( j.
dl. Frame de opciones \
principle S
<- Marco de la pantalla activa del navegador
/ 5 / i
Frame principal
16
Se generaba el enlace que se quería, al señalar el documento que se quiere mostrar
con dicho enlace se le indica en que marco se quiere mostrar, con est0 se tienen 10s
resultados deseados.
En la siguiente ventana se muestra lo explicado anteriormente.
Las imágenes guardadas desde Word son imágenes con color de fondo, para mejorar
la presentación de los documentos era necesario que las imágenes tuvieran transparencia,
eso se lograba seleccionando las imágenes, desde el editor de Front Page, al hacerlo aparece
una barra de herramientas para imágenes, se selecciona la herramienta de transparencia y se
aplica al color que se quiere hacer transparente, con esto se lograba el objetivo.
En general estas fueron las herramientas más usadas en Front Page para la edición de
los documentos HTML.
c 1.5. BASES DE DATOS EN LA
WEB UTILIZANDO ADO Y ASP I
En este proyecto se utilizaron Microsoft Active Server Pages (ASP) para incluir una página
en donde los alumnos inscritos pueden consultar sus calificaciones, creando así un
contenido dinámico e interactivo en el sitio Web. En el pasado, las secuencias de comandos
escritas en los lenguajes VBScript y JScript se procesaban en los exploradores de Web
preparados para ello. Active Server Pages permite que sea el servidor Web el que procese
los comandos de VBScript y JScript. Cualquier explorador que pueda establecer contacto
con el servidor Web admitirá los resultados dinámicos generados por ASP, tanto si soportan
VBScript o JScript así como los exploradores que no.
La aplicación más útil de ASP es la de poder conectase a gestores de bases de datos
SQL, Access, Oracle, o cualquier otro motor disponible que tenga de un controlador
ODBC.
1.5.2. REQUISITOS
Una de las grandes ventajas de utilizar la tecnología ASP es que para procesar una página
no existe ninguna restricción especial en el lado cliente, pues es indiferente al navegador
que se este utilizando, pero en el lado del Servidor es necesario alguno de los siguientes
servidores:
0 Internet Information Server 3.0 o superior (para sistema operativo NT)
o Personal Web Server (para Windows 95 y 98)
Si se cuenta con plataforma UNIX es necesario añadir un software que actúe de
interprete siendo los más conocidos:
0 Chilisoft
Instant ASP
DSN: Data Source Name. Es un identificador Único de la base de datos en el sistema. Al
definir un DSN hay que especificar tanto la ruta completa del archivo de base de datos
como el controlador adecuado a la misma (MSAccess, FoxPro, etc.). Una vez creado, es
todo lo que necesitamos saber acerca de la base de datos para poder abrirla, consultarla,
modificarla, etc.
ADO: ActiveX Data Objects. Es una familia de objetos componentes dedicados a
facilitar el acceso a bases de datos. En VBScript los objetos se crean con sentencias tipo Set
mirst = Server.CreateObject("ADODB.Recordset"), etc.
1.5.4. OBTENER UN DSN
Una vez que tenga preparado su archivo de bases de datos vaya al panel de control de su
dominio y obtenga un DSN para dicho archivo. El DSN será el identificador con el que
podrá conectar con su base de datos.
1.5.6. DECLARACIóN DEL FORMULARIO
Un formulario HTML lo componen un elemento <FORM> y diversos elementos
contenedores de datos como campos de texto, botones radio, listas seleccionables o campos
ocultos.
Entre los atributos del tag FORM destacan action y method.
Action
Permite especificar el receptor de los datos del formulario cuando el usuario pulsa el
botón enviar.
Method
El atributo method especifica el modo en que los datos son enviados, ya sea mediante
la URL (post) o variables ocultas (get)
1.5.7. LOS OBJETOS COMPONENTES DE ADO
Todo el sistema ADO se basa en una serie de objetos cuyas propiedades y métodos hay que
utilizar. Estos objetos están registrados en el sistema, sin embargo no están predefinidos, es
decir, hay que crearlos utilizando Server.Create0bject
Como valores de muchas de las propiedades de los objetos ADO se utilizan
constantes, como adOpenFonvardOnly, adOpenKeySet, etc. Todas estas constantes
empiezan por ad y están definidas en un archivo llamado adovbs.inc para Visual Basic
script y adojavas.inc para Javascript. Estos archivos los podrá encontrar en su instalación
local de ADO. Para incluirlos en las páginas ASP es necesario utilizar un código de este
tipo al comienzo de cada página ASP que use las constantes:
<!--#INCLUDE FILE="adovbs.inc"-->
Para que esta inclusión funcione el archivo adovbs.inc debe estar en el mismo
directorio que la página ASP que lo incluye
Objeto Connection
Representa una conexión a una base de datos. Este es el primer objeto que debemos
crear para poder conectar con la base de datos. Tanto el objeto ADO que nos permite
acceder a los datos (Recordset) como el que nos permite realizar consultas (Command)
disponen de una propiedad llamada Activeconnection que es una referencia al objeto
connection que enlaza con la base de datos a la que queremos atacar. De ahí que el primer
paso sea crear la conexión.
Propiedades y métodos más relevantes del objeto Connection
Connectionstring
Es una cadena de caracteres con la información necesaria para establecer una conexión
con la fuente de datos. Por tanto, es la propiedad básica de este objeto. Aunque hay hasta 7
argumentos distintos que se pueden suministrar en esta cadena, los básicos son el DSN que
identifica al archivo de base de datos y el login y password si existen. Los argumentos se
separan con punto y coma.
Ejemplo: "DSN=midsn; UID=milogin; PWD=micontraseña"
Open
Abre la conexión con la base de datos. Si antes hemos asignado la propiedad
Connectionstring, este método no necesita parámetros.
Close
Cierra la conexión con la base de datos.
Objeto Recordset
Este es el objeto ADO más importante ya que es con el que accederemos
directamente a los datos de las tablas, tanto para leerlos como para modificarlos.
Un objeto Recordset representa una tabla, que puede ser una tabla física de la base de
datos o bien una obtenida mediante una operación como un filtrado o sentencia SQL. En
cualquier caso. el objeto representa a la tabla con todos sus registros, aunque sólo uno de
ellos es el activo. El registro activo es en el que podemos leer o modificar los valores de los
campos. También se le llama cursor.
Propiedades y métodos más importantes de un Recordset
Para una mejor compresión y puesto que son numerosos, los hemos dividido por
categorías de utilidad.
Propiedades que hacen referencia al origen de los datos
Estas dos propiedades deben ser asignadas a todo Recordset, pues le dicen la base de
datos y la tabla de la que obtener sus datos.
ActiveConnection
Como se ha comentado antes, a esta propiedad se le debe asignar un objeto
connection que se haya creado previamente. Indicará al Recordset la base de datos en la
que buscar su tabla.
Source
Indica al objeto Recordset la tabla a la que representará. A la propiedad Source se le
asigna normalmente una cadena de caracteres con el nombre de la tabla. Sin embargo,
también es posible asignarle una sentencia SQL y entonces el objeto Recordset
referenciará al resultado de aplicar dicha sentencia.
LockType
Indica el tipo de bloqueo que se realiza sobre la base de datos. Por defecto toma el
valor adLockReadOnly que, como su nombre indica, sólo sirve para leer datos. Si
deseamos editar o añadir registros, tendremos que cambiar esta propiedad por otro valor. El
más usado es adLockOptimistic que permite editar la base de datos o añadir registros
realizando un bloqueo optimista (sólo cuando sea estrictamente necesario)
CursorType
El tipo de cursor que se utiliza para recorrer los registros de un Recordset. Por
defecto toma el valor adOpenForwardOnly que como su nombre indica sólo permite
moverse hacia adelante. Por ello si queremos utilizar libremente todos los métodos de
movimiento de un Recordset (MoveFirst, MoveTo, MoveNext, MovePrevious, etc.)
tendremos que cambiar el cursor por uno más potente. Esto puede hacerse asignando a esta
propiedad el valor adOpenKeyset
Propiedades que hacen referencia al número de registros
Recordcount
Número de registros de l a tabla a la que representa el objeto Recordset. Ejemplo:
EOF
Acrónimo de End Of File. Es TRUE si estamos en el último registro y FALSE
sino. Se usa mucho como condición en bucles while, los cuales se ejecutan hasta llegar
al último registro.
BOF
Acrónimo de Begin Of File. Es TRUE si estamos en el primer registro y FALSE
en cualquier otro caso.
Métodos para mover el cursor (registro activo)
Estos métodos pueden funcionar todos o no dependiendo del tipo de cursor
creado. El tipo de cursor se asigna en la propiedad CursorType. Nótese que la
asignación de propiedades al Recordset debe hacerse antes de invocar el método open
que es el que lo inicializa con registros.
MoveFirst
Mueve el cursor al primer registro de la tabla
MoveLast
23
Mueve el cursor al último registro de la tabla
MoveNext
Mueve el cursor al siguiente registro
MovePrevious
Mueve el cursor al registro anterior
Lectura y modificación de los campos del registro activo
La sintaxis para acceder a los datos de un campo del registro activo de un Recordset
es
mirecordset("Domici1io'y
Esto se usa tanto para leer como asignar valores. En nuestro ejemplo, el objeto
mirecordset representa a una tabla uno de cuyos campos tiene el nombre "Domicilio".
Así, con la expresión
dom = mirecordset("Domici1io'~
Leemos el valor del campo domicilio del registro activo y se lo asignamos a la
variable dom. Con la expresión
rnirecordset("Domici1io'y = '%/ Bretón de los Herreros 19, 1 M"
mirecordset. Update
Asignamos un valor al campo Domicilio del registro activo. Tras la edición del
registro, es necesario llamar al método Update. El motivo es que los cambios en el
registro activo se realizan sobre un buffer (espacio de almacenamiento intermedio) y no
sobre el registro propiamente dicho.
Métodos para agregar o eliminar registros de la tabla
Delete
Eliminar el registro activo es muy fácil. Basta con invocar este método. Por
ejemplo, este bucle elimina todos los clientes morosos de nuestra base de datos:
<% rstclientes. MoveFirst do while not rstclientes. EOF
ifrstClientes('Deuda'7 O Then rstclientes. Delete
end if rstClientes. MoveNext
loop %>
AddNew y Update
Crear un nuevo registro involucra dos métodos: Primero AddNew crea un nuevo
registro en blanco. Después asignamos valores a los distintos campos del registro. Por
último invocamos el método Update para que se haga efectiva la incorporación del
nuevo registro con los valores asignados.
En este ejemplo incorporamos un nuevo cliente a nuestra base de datos
<% rstclientes. AddNew rstClientes("Nombre'7 = "Pepe Gotera" rstClientes('Direccion'7 = "Rue del Percebe, 13" rstClientes("Localidud1~ = "Sildavia" rstClientes("Profesion'7 = "Chapuzas a domicilio" rsclientes. Update %>
Recuerde que para que esto funcione hay que asignar un tipo de bloqueo que
permita la edición de la base de datos. Esto se hace asignando a la propiedad LockType
del Recordset uno de estos valores: adLockOptimistic, adLockPessimistic o
adLockBatchOptimistic
Objeto Command
Este objeto es la representación de un comando que se envía a la base de datos. Este
comando puede ser una de estas 3 cosas:
Llamada a un procedimiento guardado en la base de datos.
El texto de una sentencia SQL.
0 El nombre de una tabla.
Propiedades y métodos más relevantes del objeto command
ActiveConnection
Es una referencia al objeto connection que enlaza con la base de datos. Es
imprescindible asignar esta propiedad antes de invocar el método command.execute para
ejecutar el comando.
CommandText
Este es el texto del comando. Si se trata de una consulta SQL (lo habitual), esta
propiedad es simplemente una cadena con el texto de la consulta.
Execute
El método que ejecuta la consulta. El resultado de la ejecución del comando
normalmente será un Recordset.
En el ejemplo, obtenemos un Recorset con un filtrado de la tabla Clientes en el que
se toma sólo aquellos clientes cuya provincia es Navarra.
<% Set miconexion = Server. CreateObject("'AD0DB. Connection'y miconexion. ConnectionString = "DSN=midsn" miconexion. Open Set SqlCommand = Server. CreateObject("'AD0DB. Command'y SqlCommand.ActiveConnection = miconexion SqlCommand. CommandText = "SELECT * FROM Clientes WHERE Provincia =
'Navarra"' Set rstNavarros = SqlCommand. execute I . . . . . . . I . . . . . . . . miconexion. Close %>
1.5.8. CREACIóN DE COMPONENTES ACTIVEX SERVER
Suponga que se quiere proporcionar acceso a una serie específica de funciones financieras a
través de su sitio Web. ASP no ofrece acceso a este tipo de funcionalidad, pero
conseguirlos es tan fácil como crear sus propios componentes ActiveX Server, lo que
realizará en este módulo. Llamará a su componente desde un formulario que le hemos
proporcionado.
Crear un componente
Un componente debe contener una serie de métodos (funciones) relacionados que
ofrecen un valor añadido al que proporciona el lenguaje de secuencia de comandos que lo
llama. Ya que VBScript no ofrece todas las posibles necesidades, debe crear sus propios
componentes en Visual Basic.
Iniciar Visual Basic
l . Haga clic en el botón Inicio en la barra de tareas.
2. Seleccione Visual Basic r
3. Haga clic en Visual Basic en el submenú para ejecutar el entorno de diseño.
Dar nombre al proyecto
Visual Basic utiliza el nombre del proyecto como la primera parte del nombre al que
se hace referencia cuando se utiliza el componente de servidor en una secuencia de
comandos ASP.
l. Haga clic en Herramientas.
2. Seleccione Opciones.
3. Haga clic en la ficha Proyecto.
4. Haga doble clic en el valor Proyectl en la caja de texto Nombre de proyecto.
5. Escriba el nombre del proyecto y haga clic en Aceptar.
Más tarde, se referirá al componente de servidor Finanzas desde una secuencia de
comandos ASP como NombreDelProyecto. Finanzas.
Agregar una clase al proyecto
Para crear en Visual Basic un componente con un conjunto de funcionalidades a las
que puede llamar, debe definir una clase.
Agregar un método a la clase
El componente de servidor creado requiere algo de código de programación. Este
código hará que la función incorporada de Visual Basic este disponible para los lenguajes
que hagan uso de su componente.
Agregar el punto de entrada del componente
Todos los componentes de servidor necesitan un punto de entrada (principio). Éste
será el código que será llamado cuando el objeto se encuentre disponible por primera vez
para un lenguaje. En VBScript, cuando utiliza Server.CreateObject, se crea una instancia
de un objeto. Cuando se ejecuta la instrucción Server.CreateObject, se llama al
procedimiento Sub Main de un componente de servidor (creado con Visual Basic).
Su componente Finanzas no tiene que hacer nada especial para iniciarse cuando se le
llama. Por esa razón, puede ofrecer un procedimiento Sub Main vacío (sin sentencias
Visual Basic).
l . En el menú Insertar, seleccione Modulo.
2. En la ventana Modulo 1, escriba Sub Main.
3. Pulse ENTRAR.
Esto inserta automáticamente el siguiente código:
Sub Muin()
End Sub
Guardar el proyecto Finanzas
Cuando guarde su trabajo, se le pedirá que guarde las tres partes de su proyecto
Visual Basic. Esto incluye el archivo del proyecto, el módulo de clase y el módulo de
código.
Hacer que el componente sea un componente en proceso
Visual Basic le permite crear componentes en proceso ActiveX (llamados
anteriormente Servidores de automatización OLE) y componentes fuera de procesos
ActiveX. Un componente ActiveX en proceso es una biblioteca de vínculos dinámicos
(archivo con extensión .dll) que se carga por el proceso que la llama. Un componente
ActiveX fuera de proceso es un archivo ejecutable (archivo con extensión .exe) que se
ejecuta como un proceso separado de la aplicación que le llama. Ya que los componentes
en proceso están en el mismo área de proceso que el programa que les llama, ofrecen un
rendimiento mejor que los componentes fuera de proceso.
Para hacer que el componente de servidor Finanzas sea un componente ActiveX en
proceso efectuar los siguientes pasos:
l . Abra el menú Archivo.
2. Seleccione Crear archivo DLL de OLE.
3. Haga clic en el botón Opciones.
4. Seleccione la casilla de verificación Incremento automático.
5. Haga clic en Aceptar.
6. Salga de Visual Basic.
Registrar el componente de servidor creado
Todos los componentes de servidor deben ser registrados. Windows NT y Windows
95 hacen uso del sistema de registros para hacer el seguimiento a los componentes de
servidor que están disponibles. Al registrar el componente de servidor, este puede ser
llamado por VBScript y todos los demás lenguajes compatibles OLE que tenga en su
equipo.
l. Abra una ventana de Símbolo de MS-DOS.
2. Escriba cd Unidad de disco: \winnt\system32
3. Pulse la tecla ENTRAR.
4. Escriba regsvr32 Finanzas.dl1.
5. Pulse la tecla ENTRAR.
6. Haga clic en el botón Aceptar cuando aparezca la ventana de diálogo que diga
DllRegisterServer in finanzas.dl1 succeeded.
7. Cierre la ventana de Símbolo de MS-DOS.
Llamar al componente creado desde una secuencia de comandos
Para probar el componente, puede llamarlo desde Active Server Pages (ASP), Visual
Basic, productos de MicrosoftB Office que utilicen Visual Basic para Aplicaciones o
cualquier otro controlador de automatización OLE.
Para llamar al componente de servidor, creado desde Active Server Pages utilizando
VBScript, puede utilizar un formulario HTML como entrada.
El formulario HTML
Se utilizará un formulario HTML para recoger los valores de entrada. Estos valores
son variables asignadas que están disponibles para una secuencia de comandos ASP como
parte del objeto Request. Puede hacer referencia a un valor desde un formulario HTML.
Los datos pueden ser referenciados utilizando Request("dato"). La etiqueta HTML
<INPUT TYPE=TEXT NAME=APR> proporciona el campo de entrada necesario para
introducir un valor.
Para enviar el formulario a un servidor Web de Microsoft que utilice ASP, el usuario
tiene que pulsar el botón Enviar. El botón Enviar llama a la página indicada por la
propiedad ACTION de la etiqueta del formulario HTML. La etiqueta HTML para el botón
Enviar (<INPUT TYPE=SUBMIT VALUE="Hacer consulta">) utiliza el valor de
ACTION de la etiqueta del formulario HTML (<FORM METHOD=POST
ACTION="Consulta.asp">) para llamar a la página ASP Consulta. asp.
La secuencia de comandos
VBScript se utiliza para llamar a su componente de servidor Finanzas. La secuencia
de comandos empieza validando las entradas del formulario HTML y asignando valores
predeterminados a cualquier valor que no se haya introducido en el formulario.
Server.CreateObject se utiliza para crear una instancia de su componente Finanzas
llamada NombreComponente.NombreCZase. Una vez que se crea una instancia de un
componente de servidor, puede hacer uso de sus métodos y propiedades. En la secuencia de
comandos que sigue inmediatamente a Server.CreateObject, se pueden utilizar las
propiedades y métodos declarados en la clase.
1.6. ESTRUCTURA BÁSICA
DEL SITIO WEB
En cuanto al diseño del sitio Web, se pensó en un sitio que fuera fácil para navegar y de
carga rápida para los navegadores de Internet más comerciales (Internet Explorer y
Netscape); para la elaboración de dicho diseño se visitaron diversos sitios en Internet y de
ahí se llegó a una conclusión del tipo de sitio que se quería realizar, enseguida se presenta
un diagrama en el que se muestra, a grandes rasgos, el tipo de sitio Web que se construyó.
I Titular I
Como se puede ver, en el diagrama se muestra la página de inicio del sitio construido,
dicha página consta de tres frames: el frame izquierdo contiene un menú con los enlaces
suficientes para poder navegar fácilmente a través del sitio; ejemplos de dichos enlaces son:
enlaces a las diferentes unidades del curso y enlace a las utilerías que se ofrecen a los
alumnos.
El frame superior contiene un encabezado, ya que dicho frame no contiene
información indispensable, el usuario puede modificar su tamaño hasta el punto de
eliminarlo y así poder visualizar el contenido del curso en una ventana aún mayor.
El frame principal es el de la parte derecha de la página, contiene toda la información
tanto del curso como de las utilerías presentadas al usuario. Enseguida se explica con más
detalle la estructura del sitio Web. Para eso se muestra un diagrama de árbol con los enlaces
más representativos del sitio Web.
Bienvenida
Contenido del Curso
Temario Unidad 1
Temario Unidad 2
Temario Unidad 3
Temario Unidad 4
Temario Unidad 5
Ventana Principal
Dicho diagrama muestra lo siguiente:
El curso consta de cinco unidades, en el frame izquierdo se encuentra un enlace a
cada una de esas unidades, al navegar mediante cualquiera de esos enlaces se mostrará, en
el frame de la derecha, el temario detallado correspondiente a la unidad que se quiera
consultar; el usuario tendrá la posibilidad de ir directamente al subtema que quiera
consultar, en cada una de las páginas del contenido del curso se encuentra un enlace para
poder regresar al temario detallado de la unidad en la que se encuentre, es decir, si el
usuario consulta un subtema de la unidad 111, al accionar el enlace de regreso al temario se
mostrará el temario correspondiente a la unidad 111.
Otro enlace que podemos encontrar en el frame izquierdo, corresponde al de las
utilerías, al accionar dicho enlace se muestra en el frame de la derecha una página con una
liga para cada una de las diferentes utilerías, como son, programas, PDF’s, etc. Otro enlace
contenido en el frame izquierdo corresponde al de la página de bienvenida o de inicio.
Enseguida se muestran diagramas de árbol para cada una de las unidades, en donde se
ven todos los enlaces contenidos en cada unidad.
cuadrático medio
Evaluacibn de
Discusción breve
Introducción:
tiempo
/A i;cuperacián de
B T e m a r i o Unidad at2 3 Teorema del
muestreo, convolución
W M u e s t r e o Natural
Funciones de enrgía
Función de Correlación.
Transmisión de señales a traves de sistemas lineales
Transmisión de una señal sin distorsibn
Filtros ideales
Criterio de Paley-Wiener
Modulación de amplitud.
AM de portadora suprimida [AM DSB.SC)
AM De gran portadora [AM DSB-LC]
Potencia de la portadora y las bandas laterales en una señal AM
Generación de seRales AM DSB-SC
Modulador AM de conmutador.
Modulador AM no lineal
Demodulación de una señal AM DSB-SC.
Generación de señales AM DSB-LC
Demodulación de una señal AM DSB-LC.
única [AM SSH].
Demodulación
SSB.
residual [YSB]
En los diagramas anteriores se puede apreciar cuales son los temas que corresponden
a cada unidad. Algunos temas contienen subtemas. En cuanto al diseño de las páginas
correspondientes al contenido del curso, se pensó en páginas con una carga ligera de
contenido, para que se pudiera navegar a través de ellas de una forma rápida. Por ejemplo
cuando un tema contiene subtemas y cada subtema contiene demasiada información, se
diseñó una página para cada subtema, de esta forma el usuario esperará un tiempo mínimo
para poder visualizar las páginas completamente.
1.7. CONSTRUCCION
UNA PÁGINA ASP
Como la página se construy6 con el objetivo de apoyar a un curso impartido en la UAM,
optamos por construir una página donde los alumnos pudieran consultar sus calificaciones
en forma totalmente privada, es decir, la calificación que se mostrará a un alumno será
únicamente la suya, no podrá ver la calificación de algún compañero; a menos que conozca
su nombre completo, su matrícula y su RFC.
Considerando que esta página es un pequeño sistema, aplicamos la metodología y
filosofía de Orientación a Objetos, quedando el siguiente modelo con un solo Use Case.
1.7.1. MODELO DE ANÁLISIS DE REQUERIMIENTOS
1. Identificación de las Transacciones Núcleo
UC 1 Consulta Calificaciones
2. Diagrama de Use Cases
Alumno UC 1 Consulta de calificaciones
3. Identificación de los pasos y casos más simples para cada Use Cace.
37
Alumno UC 1 Consulta de calificaciones
UC 1 consulta de calificaciones
1. Alumno. Escribe su nombre completo con mayúsculas
2. Alumno. Escribe su matrícula
3. Alumno. Escribe su RFC
4. Alumno. Presiona el botón Buscar Nombre
5. Sistema. Envía los datos al servidor
6. Sistema. Busca la calificación del alumno
7. Sistema. Regresa las calificaciones del alumno
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio Enviar
/
Teclea datos \
I
Resultados t-"
Regresar Salir
Modelo del dominio del problema.
Podemos observar que sólo habrá una sola clase estática, y corresponderá a la clase
Calificaciones:
Calificaciones
Nombre
Matricula
RFC
Parcial 1
Parcial 2
Parcial 3
Parcial 4
1.7.2. MODELO DE ANALISIS DINÁMICO
UC1. Consulta de calificaciones
1. Descripción del escenario correcto más simple
2. Diagrama de Colaboración
2 2 5 8 9 5 l . EscribeNombreO 6. Conecta()
oIBusca I __+ oIBuscaDatos +__+ I 2. EscribeMatriculaO 7. Busca(Nom,Mat,RFC,result) 3. EscribeRFCO 8 , DespliegaResultO I
5.
oNValida
4. Diagrama de Clases Dinámicas
<<event>>EscribeNombre() I cIBuscaDatos I I Valida(Nom,Mat,RFC,result) I
<<event>>EscribeMatricula() ------------ Conecta()
<<event>>EscribeRFC() Busca(Nom,Mat,RFC,Result) t 1 <<event>> Buscar() Despliega(Resu1t)
I 2. DISEÑO DE LOS PROGRAMAS I
Para el desarrollo de los programas, se pensó desde un principio utilizar el lenguaje Visual
Basic, pero para poder entender bien la arquitectura orientada a objetos primero se estudió
el lenguaje de programación C++, dichos estudios nos permitieron entender mejor todos los
conceptos necesarios para la programación orientada a objetos sin importar el lenguaje que
después se estudiará. Por lo mismo se presentan enseguida los conceptos más importantes
de la programación orientada a objetos.
2.1. ESTUDIO DEL LENGUAJE
DE PROGRAMACI~N c++
En cuanto al lenguaje de programación que se utilizará, hemos ac ordado utilizar un
lenguaje de programación orientado a objetos. Para poder aplicar algún lenguaje visual es
necesario saber programar en un lenguaje orientado a objetos, en este caso nuestro objetivo
es aprender Visual C, por lo cual es necesario conocer todas las herramientas que nos
ofrece el lenguaje de programación C++.
Entre los avances obtenidos en este tema se encuentran los siguientes:
Se ha aprendido que para poder definir objetos, es necesario primero definir clases, y
aprender los conceptos de herencia, funciones amigas, constructores, destructores,
sobrecarga de funciones y operadores, entre otros.
Enseguida se presenta una tabla que muestra conceptos fundamentales y en seguida
una breve explicación. . Gonce to Clase.
Explicación. Una clase es un tipo de dato similar a una estructura en C, la diferencia es que una clase no sólo contiene variables sino también funciones.
Estas funciones son muy esDeciales va aue se declaran como
funciones públicas y sólo estas tienen acceso a los datos privados de la clase en la que se definen.
Constructores.
Destructores
Funciones amigas
Herencia
Objeto
Una función constructora es aquella que se crea dentro de una clase y que tiene por objeto inicializar las variables privadas de la clase, la ejecución de estas funciones se realiza automáticamente al crear el objeto. Una regla que no se debe de olvidar es que estas funciones deben tener el mismo nombre que la clase en la que se definen. Una función destructora también se define dentro de una clase y su objetivo es el de eliminar todas aquellas variables que ocupan espacio en memoria, la ejecución de estas funciones se realiza automáticamente al terminar el programa, una característica de estas funciones es que su nombre debe ser el mismo que el nombre de la clase precedido de el carácter -, por ejemplo si la clase se llama casa, la función destructora debe llamarse -casa. Este tipo de funciones también tienen su propia característica, la cual es que pueden acceder a la parte privada de una clase sin pertenecer a la misma, esto se logra si la función se declara como amiga (friend). Este concepto es sin duda uno de los más importantes ya que gracias a esta característica de C++ se pueden crear los objetos, la herencia consiste en heredar a una clase las características de otra, esto se logra definiendo una clase dentro de otra ya definida. Un objeto es un ente lógico que contiene datos e instrucciones que manipulan a dichos datos, es también un caso particular de una clase.
Otra diferencia que hemos encontrado en este lenguaje con respecto a C es que tiene
mayor ambigüedad, por ejemplo, se pueden llamar a dos funciones con el mismo nombre,
un ejemplo de esto son las funciones cin y cout, dichas funciones son funciones de entrada
salida, cout despliega en pantalla, una cadena de caracteres, un carácter, un entero o un
flotante, esto lo hace sin necesidad de que se le diga al compilador que tipo de dato se está
enviando a la salida.
Cin funciona de manera análoga a la función anterior, en este caso la función cin
toma datos de entrada, que el usuario ingresa, sin importar que se trate de un entero, un
flotante o una cadena de caracteres, el compilador manda el valor tomado a la variable que
corresponda.
De esta manera, podríamos nombrar aun más características del lenguaje de
programación estudiado, sin embargo, nuestra intención es nombrar solo las características
más importantes y las ideas más generales del lenguaje.
El aprender este lenguaje de programación es muy importante, ya que entre las
utilerías que se pretenden ofrecer a los alumnos se encuentra el desarrollo de programas que
hagan más fácil la comprensión de los temas, pero no sólo esto, hemos visto que para el
desarrollo de páginas Web también podemos aplicar lenguajes de programación como C++
en los Scripts, es decir, no sólo Java es un lenguaje que se puede aplicar a HTML, también
lenguajes orientados a objetos nos pueden servir en determinado momento.
E3 2.2. ALGORITMOS MAS USADOS
Para el desarrollo de la mayoría de los programas, el objetivo era construir procedimientos
para evaluar funciones que el usuario ingresara, por ejemplo, si el usuario teclea la función
sen(x+5.3), el programa debe reconocer la función y poder evaluarla en diferentes valores
de x, se necesitaron implementar funciones o procedimientos que simularan listas ligadas,
conocidas en el lenguaje C, una dificultad que se encontró es que Visual Basic es un
lenguaje que no cuenta con soporte para apuntadores, el objetivo era simular listas ligadas o
estructuras de árbol, para ello se generó un nuevo tipo de dato en Visual Basic, dicho tipo
de dato era de la siguiente forma.
Type nuevo num As Double car As String band As Integer
End Type
La sintaxis que se está mostrando es la misma que para Visual Basic, aquí se declara
un tipo de dato llamado nuevo, el cual contiene tres elementos num, car y band. Con la
siguiente instrucción se crea un arreglo de tamaño variable con el nuevo tipo de dato, con
esto se ha generado la simulación de la lista ligada, se pensó que fuera de tamaño variable
para que el uso de memoria del programa fuera mínimo.
Public lista() As nuevo
Se tenían que generar funciones para convertir la función ingresada por el usuario por
una lista simulada. Por ejemplo, si se tenía la siguiente función: sen(x+2.34), primero se
convierte la cadena en lo siguiente: s(x+2.34), posteriormente se convierte en una lista
como sigue:
S 1 2.34 + X
El siguiente paso es convertir la lista en una nueva lista pero en forma postfija, para
este ejemplo la lista queda como sigue:
X I 2.34 1 + S
Para convertir la cadena “sen” en solo el carácter “S” se siguen los siguientes
criterios.
Para ilustrar más claramente el procedimiento se escribirán en pseudocódigo las
funciones más importantes que se necesitaron.
funcion Post$jo(nuevo lista(), nuevo postjijo(), entero primero, entero ultimo)
entero mit, alc, aux; siprim = ult entonces
otro si lista(prim).car = "(,' And lista(ult).car = ':,''And Corresponde(prim, ult) = True
Postfijo (lista, post, prim + I , ult - I) Otro si es unaria(lista(prim).car) Andpartebrim, ult) O entonces
push (lista@rim).car, listabrim). band, lista(prim).num)
entonces
Postj~o-~istu. post, prim + 2, ult - I) push (lista(prim).car, lista(prim). bund, lista@rim).num)
mit = parte(lista, prim, ult) si lista(prim).car = 'I(,, And lista(mit - I).car = '7'' Then
otro
Fin si si lista(mit + l).car = "(,'And lista(ult).car = '9'' entonces
otro
Fin si push (listu(mit).cur, lista(mit). band, lista(mit).nurn)
otro
Postfijo (lista, post, prim + I , mit - 2)
Postjijo (listu, post, prim, mit - 1)
Postfijo (lista, post, mit + 2, ult - I )
PostJjo (lista, post, mit + 1, ult)
Jin si Fin
Enseguida se da una explicación de cómo está estructurada la función.
Los parámetros de la función son la lista post que es un arreglo de tipo nuevo, y los
limites de la lista son prim y ult; como se puede ver la función es recursiva y hace llamadas
a otras funciones, por ejemplo, la función parte, que regresa un entero como índice en
donde encuentra el operador que parte la función a convertir, si no encuentra dicho
operador regresa -1. Por ejemplo:
x+1 1 sen(x+l) -I (2*x)+sen(x+2) 5
Otra función a la que hace llamada es push, en esta función se inserta en la parte alta
del arreglo post el nuevo elemento que se quiere insertar.
La función Corresponde recibe como parámetros la lista y los límites de la misma,
para haber llamado esta función fue necesario que listu(prm)= "(" y listu(ult)= '> ", la
función checa si el paréntesis que abre corresponde al paréntesis que cierra regresando un
valor boleano. Por ejemplo:
(5+3) true (x)*sen(x) false
Otra función de suma importancia es la que evalúa el arreglo postfijo, en esta se ve el
porque de la forma del tipo de dato, nuevo. Para poder entenderla se muestra el
pseudocódigo enseguida.
Double función evuluugostCfuncion0 As nuevo, X A s Double) entero bund, cont, cont2; double num, resp; string cur; nuevo q0; cont = O; haz
si funcion(cont). car = ''x" entonces resp = X; q(cont2). bund = O; q(cont2).num = resp; q(cont2).car = O;
cont2 = cont2 - I ; resp = aplica unario(q(cont2). num, funcion(cont). cur); q(cont2). bund= O; q(cont2).num = resp; q(cont2).cur = O;
resp = aplica binurio(q(cont2 - 2).num, q(cont2 - I).num, funcion(cont).car); cont2 = cont2 - 2; q(cont2).band = O; q(cont2). num = resp; q(cont2).cur = O;
resp = firncion(cont).num; q(cont2). bund = O; q(cont2).car = O; q(cont2).num = resp;
otro si es - unuriadfuncion(cont). cur) entonces
otro si es binariu funcion(cont),cur) entonces -
-
otro
otro si
cont = cont + 1; cont2 = cont2 + I ;
Loop mientras cont <= tamqost Regresa(resp);
f in
Como se dijo anteriormente esta función evalúa el arreglo post, y recibe como
parámetros el arreglo post y el valor de x en el cual hay que evaluar la expresión postfija.
La estructura de la función es iterativa, en ella se hacen llamadas a otras funciones, las
cuales son las siguientes:
es - unariafuncion(cont). car): Esta función regresa true si funcion(cont).car corresponde a un carácter de alguna función trigonométrica o exponencial o la escalón unitario.
es - binariaCfuncion(cont).car): Esta función regresa true si funcion(cont).car corresponde a un carácter de algún operador binario tal como +, - *, /, de lo contrario regresa false.
El resultado de la evaluación de la expresión está contenido en la variable resp.
Una parte fundamental de todos los programas es la revisión gramatical de las
expresiones que los usuarios ingresan. En los programas se pensó en un desarrollo similar
al que usan los compiladores, por ello se desarrollaron funciones de análisis sintáctico,
enseguida se presenta el desarrollo de las funciones usadas para el análisis de las
expresiones.
2.2.1 GRAMÁTICA PARA VALIDAR FUNCIONES
La validación de la ecuación de entrada no fue sencilla, ya que para su evaluación se debía
cumplir con los siguientes requisitos:
1. La variable a utilizar será x en minúscula.
2. Se pueden hacer operaciones de suma (+), resta (-), multiplicación (*) y división(/), por
ejemplo:
2 *x+x/3 - 1
3. Las expresiones con exponente se escribirán de la siguiente manera:
4. Este programa soporta funciones del tipo sen(x), cos(x), tan(x), ctg(x), sec(x), csc(x),
ctg(x), ln(x), log(x), exp(x) y u(x), escribiendo siempre el argumento entre paréntesis.
Por ejemplo:
x* sen(x"2)
5. Los números negativos se deben escribir entre paréntesis, ejemplo:
(-5)+x
u(-sen(x))
6. Al verificar que la gramática de cierta función estuviese bien escrita, se debe cumplir con r-j 0
los siguientes puntos: { j < . O
r'l :: -: 12
0 El número de paréntesis que abren debe ser igual al número de paréntesis que 3 r, .7: y?
cierran. tn
0 No escribir letra mayúscula alguna. kq!
o La variable independiente es x. 98
E')
R'; 9 ' g E, 6 2 d a
o No escribir operaciones binarias juntas. Ejemplo: x+-3.
0 Escribir números racionales de la siguiente forma: 0.546, más no, S46.
o La multiplicación entre términos debe ser estrictamente con el símbolo *, por
ejemplo, la siguiente sintaxis es incorrecta: 3x, la forma correcta es la siguiente:
3 *x.
O No dejar espacios en blanco.
49
De lo anterior podemos ver que la construcción de un algoritmo para validar una
ecuación de la cual no conocemos su ni forma o sintaxis, es una tarea difícil, por lo que
tuvimos que recurrir a una herramienta computacional más apropiada para estos casos sin
dejar de un lado la orientación a objetos, así con ello logramos obtener una buena
combinación de anrilisis orientado a objetos y diseño de autómatas para validar l a función.
A continuación se presentan algunos de los conceptos más importantes para
construir un Analizador Sintáctico, el cual fue usado para hacer la validación de la
ecuación.
Alfabeto
Conjunto de símbolos distinguibles entre sí, con los cuales podemos expresar
conceptos. Un alfabeto se representa con el símbolo C.
Palabra (cadena)
Sucesión (concatenación) cualquiera de los símbolos de un alfabeto C
Longitud de una cadena: Numero de símbolos que la conforman.
Concatenación: Operación entre cadenas que consiste en unir dos o más palabras.
Cadena vacía (E): Cadena cuya longitud es cero.
Léxico
Es un vocabulario, diccionario, conjunto de todas las cadenas (palabras) válidas que
se pueden formar a partir de un alfabeto C dado.
Sintaxis
Parte de l a gramática que enseña a combinar (unir) palabras para formar expresiones
(oraciones)
50
Gramática 2 2 5 8 9 3
Conjunto de reglas que nos permiten combinar correctamente palabras para expresar
un concepto (o idea) claro y completo, carente de ambigüedad.
Formalmente (matemáticamente hablando) una gramática es una tupla formada por
los siguientes elementos:
G = (V,T,P,S) donde:
V. Conjunto de elementos variables, los cuales vamos a designar entre los símbolos
menor que (<) y mayor que (>).
T. Conjunto de elementos terminales los cuales forman parte del alfabeto C ya sea de
manera individual o formando una cadena (palabra), a los cuales los vamos a
subrayar.
P. Conjunto de reglas de producción. Con este conjunto de reglas es que se pueden
combinar correctamente las palabras (cadenas) para construir una frase válida.
S. Conjunto de elementos variables formado por un solo elemento, cuyo objetivo es el
de indicar cual es la primera regla de producción que se utiliza para formar una
expresión. Se le conoce como símbolo distinguido.
Clasificación de las posibles gramáticas según Chomski:
Tipo O: Gramáticas que se conocen con el nombre de Gramáticas Irrestrictas.
Tipo 1 : Conocida como gramática Sensible al Contexto.
Tipo 2. Conocida como Gramática Libre (Independiente) de Contexto. Esta gramática
es la que se utiliza para diseñar y construir un Analizador Sintáctico.
Tipo 3. También llamadas Gramáticas Regulares.
2.2.2. DEFINICIóN DE LA GRAMÁTICA PARA HACER LA VALIDACIóN
DE UNA ECUACIóN DE ENTRADA
V = {<ExpresionSimple>, <Signo>, <Termino>, <Factor>, <Numerico>,
<Operador>, <CaracterN>, <Caracter>}
T = {ADDOP, MULOP, [, 1, x, NUM, MENOS, :, sen, cos, tan, sec, csc, ctq, In, log,
9, u}
S = {<ExpresionSimple>}
P: Usando diagramas de Transición Modificado.
1. <ExpresionSimple>:
+ <Termino> b
<Termino> 4- ADDOP
2. <Termino> :
+ <Factor> b <Termino> 4- MULOP
3. <Signo>:
MENOS
4. <Factor>: <Signo> + <ExpresionSimple> "b 1
b <Operador>
5. <Numerico>: b
NUM <Numerico>
-+ <CaracterN>
6. <CaracterN>:
4 NUM + <Caracter> ___+
<ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple> <ExpresionSimple>
En cuanto al diseño de los programas de tipo orientado a objetos se utilizó el modelo
UML y con ello poder entender como se diseñaron los programas. A continuación
presentamos un resumen sobre UML, y después como se aplica para el diseño de dos
programas de ejemplo.
2.3. PRINCIPIOS PARA EL ANALISIS Y
DISEÑO ORIENTADO A OBJETOS
Enfoque Orientado a objetos con Notación UML
El enfoque de orientación a objetos es una forma de observar la realidad. El enfoque como
su nombre lo indica se basa en el concepto de objeto:
Es todo aquello que pueda distinguirse dentro del universo de la aplicación
que sea Único. Los objetos tienen propiedades o estados y la única forma de afectar
esas propiedades y estados es a través de los comportamientos que exhibe el objeto.
La concepción del objeto en este momento no es muy espectacular pero, ya que no
limitamos las características de los objetos, éstas pueden ser por sí mismas otros objetos.
De tal forma que estamos en una posición muy interesante: los objetos pueden estar
compuestos de otros objetos más elementales.
Clases e Instancias
Dentro de la definición de objetos se encontrarán algunos que serán muy parecidos, ya
sea que comparten la misma definición de características. Ya que todos esos objetos se
parecen mucho, podemos establecer que esos objetos son obtenidos del mismo molde o de
la misma plantilla. Tal molde o plantilla se le denomina Clase. Una clase es una ayuda
notacional en el análisis para establecer las propiedades y funciones que serán comunes a
todos los objetos que se generen a partir de ella.
En la siguiente figura se pueden ver dos ejemplos de clases, correspondientes a
objetos Empleados y Articulos. Note que cada clase se describe a través de un rectángulo en
el que hay tres divisiones: la primera indica el nombre de la clase, la segunda contendrá
todas las propiedades que deben tener cada objeto y la tercera contiene las funciones por
medio de las cuales se modifican las propiedades de los objetos.
Empleado 4 C l a v e E m p ~
;%NombreEmp l.%DireccionEmp ;BoRFCEmp
' *Contratacion( ) 8 *Liquidation( ) ~
' *Jubilation( ) ' ~~
,%DescripArt 3bPrecioArt %ExistenciaArt
Ejemplos de clases.
En particular se utilizará la notación correspondiente al UML: Lenguaje Unificado
de Modelado, el cual es en la actualidad el modelo de notación que tiene mayor aceptación
dentro de la comunidad de desarrolladores con Orientación a Objetos.
De lo anterior se puede decir que todo objeto está asociado a la clase a partir de la que
se generó. A cada objeto generado se dice que es una instancia de la clase, el cual tendrá las
propiedades y funciones indicadas en la clase.
Encapsulamiento
Los objetos tienen una conceptualización interesante, pues lo que interesa de ellos es lo
que puedan realizar y no cómo lo hagan y más aún, cómo estén construidos a su interior.
Este concepto lo utilizamos en nuestra vida diaria, de tal forma que no nos interesa como
están por dentro la televisión o el automóvil (la mayor parte de las veces). A esta propiedad
se le conoce como encapsulamiento.
Desde el punto de sistemas esta propiedad que puedan tener los objetos es de gran
interés pues la forma en que está construido un objeto es irrelevante, lo importante es lo que
puede hacer y eso está dado a través de sus funciones. Por lo mismo, la detección de errores
dentro de un sistema es más fácil de realizar si el código sólo puede accederse desde puntos
perfectamente especificados.
Polimorfismo
Otro ejemplo puede ser cuando una cierta sección de código le dice a una ventana que
se despliegue en la pantalla. Es claro que si cada ventana es un objeto y éstas son distintas,
cada una se desplegará de acuerdo a sus propiedades, sin embargo, desde el punto de vista
del objeto que está ordenando que se abra una ventana, no importará si es una ventana o la
otra, sólo ordena que se despliegue la ventana que está solicitando.
Este comportamiento se conoce como Polimorjsmo. El polimorfismo se define como
la característica de que el objeto que pide la ejecución de una función a otro objeto, no
necesita saber la naturaleza del objeto dueño de la función. En la siguiente tabla se observa
el manejo con y sin polimorfismo en C++.
Versión sin Polimorfismo Function Abreventana v) I t switch (v.Tipo) {
case TI: abre - ventanal 0; case T2: abre ventana20; break
-
1
Versión con Polimorfismo Function Abreventana v) {
1 K A bre Ventanao
Comparación de código sin y con polimor-smo
Herencia
Como se indicó en la sección anterior, cuando nos enfrentamos a objetos nuevos, a
veces tenemos una cierta noción acerca de cómo se pueden utilizar. Suponga que le prestan
un automóvil que es de un modelo que nunca había manejado. L o más seguro es que usted
pueda manejarlo sin ningún problema, ya que su auto y el que le prestaron se parecen,
aunque no son objetos que necesariamente correspondan a la misma clase, puede ser que el
auto que le prestaron tenga transmisión automática y el suyo sea estándar.
Entonces ¿cómo es posible que compartan características? La razón es que l a clase a
la que pertenece su auto y la clase a la que pertenece el otro auto se parecen, aunque
manejan algunas propiedades distintas. Veamos que los dos autos tienen cuatro ruedas,
motor, compartimento para pasajeros, volante, etc. sólo difieren en ciertos aspectos.
En este caso es posible generar una clase que contenga todas las descripciones de las
propiedades en común de las dos clases en cuestión. Esta nueva clase será la base para las
dos clases que ya teníamos. A continuación se muestra está situación en la siguiente figura:
%Marca ,%Modelo
' *Avance( ) ' *Retroceso( )
' *CambioVelocidad( ) ' 1 . *ActivaSobreMarcha( )
Clases y Subclases. La clase Automóvil tiene las subclases Estúndur y Automútico.
La forma en que se lee este diagrama es que la clase Automóvil tiene dos subclases
especializadas que son Estúndur y Automático. Lo relevante de este concepto es que las
subclases contienen las propiedades y las funciones definidas en la clase principal. Esto
quiere decir que tanto Estúndur como Automútico tienen las propiedades Marca, Modelo,
Año, Placas y Dueño, de la misma forma en que están especificados en la clase principal,
sin embargo, los métodos en ambas subclases tienen el mismo nombre de la clase principal,
aunque no necesariamente son iguales.
En la notación de UML la relación de herencia entre dos clases se indica por medio
de una flecha hueca que apunta a la clase ascendiente, esto es, porque en una relación de
herencia, el padre no se construye teniendo en cuenta que se puedan derivar de é1 clases
más especializadas. Por otro lado, las clases que son descendientes es importante que sepan
quién es su ascendiente pues de é1 están tomando propiedades y funciones.
Proceso de Análisis
Una vez establecida la forma de trabajo, describiremos la primera parte de todo el
proceso de desarrollo que está planteado con la creación del Modelo de Análisis.
Descripción del Proceso
En realidad el proceso de análisis está compuesto por dos procesos más elementales
que generan a su vez dos modelo detallados como se puede ver en la siguiente figura
Proceso de Análisis de usuario / de requerimientos
Modelo de Requerimientos Requerimientos
\
Modelo de
Proceso de Análisis Análisis
Modelo de Análisis dinámico ", Análisis Dinámico
-
Proceso de Andisis.
La primera parte la constituye el Proceso de Análisis de Requerimientos, en donde se
recolectan todos los requerimientos del usuario, se unifican en formato y se genera una
especificación bajo ciertos formatos estándares que garanticen que todo el equipo de
desarrollo pueda manejar los requerimientos. Una vez obtenido el modelo de
requerimientos, se puede proceder a establecer un modelo dinámico del sistema para
establecer las características principales de la estructura del sistema.
Es claro que el proceso de análisis dinámico se alimenta del modelo de
requerimientos para poder generar su modelo de análisis dinámico.
El Modelo de Requerimientos se constituye a su vez de tres modelos:
Modelo de Casos
0 Modelo de Interfaz
0 Modelo del Dominio del Problema
El Modelo de Cusos extrae el conocimiento funcional fundamental del problema de
una forma estructurada y progresiva, siendo la base para establecer la estructura del
sistema. Este modelo orienta todos los demás procesos del método.
El Modelo de Interfaz establece el vínculo visual entre el desarrollador y el usuario
para concretar aspectos de l a interacción que el sistema pudiese tener con su entorno
externo, permitiendo la retroalimentación temprana de aspectos fundamentales para el
conocimiento de la aplicación.
En el Modelo del Dominio del Problema se establecerán los principales objetos que
constituirán al sistema y las relaciones que tienen entre sí.
Modelo de Análisis
El modelo de requerimientos establece el comportamiento externo del sistema y en lo
específico del caso que se esté analizando. Esto se plantea definiendo la forma de la
transacción, identificando los elementos visuales que estarán actuando en la interfaz y los
objetos que se originan por la misma aplicación.
El siguiente paso es identificar las interacciones más significativas entre los objetos
obtenidos y por supuesto descubrir nuevos objetos que pueden ayudar a llevar a cabo la
interacción. L o anterior constituye el principal objetivo del proceso para la obtención del
Modelo de Análisis.
Tipos de Objetos
En un nivel conceptual amplio todos los objetos son iguales, sin embargo, pueden
establecerse ciertas funciones específicas a los objetos que componen un programa o
sistema y por lo mismo pueden establecerse categorías para los objetos que componen un
programa. Estas categorías permiten mejorar los aspectos de calidad interna de los
componentes de los programas pues exhiben mejores niveles de cohesión y acoplamiento
que son elementos con los que se evalúa la calidad de un sistema.
Las categorías más simples de objetos son:
Objetos Interfaz
m Objetos de Negocios
Objetos de Datos
En UML con extensión de Objectory la notación para describir objetos de interfaz es
la siguiente:
<<Nombre del Objeto Interfaz>>
En UML con extensión a Objectory la notación para describir objetos de negocio o de
control es la siguiente:
<<Nombre del Objeto de Negocio>>
En UML con extensión a Objectory la notación para describir objetos de datos o
entidad es la siguiente:
O <<Nombre del Objeto de Datos>>
Modelo de Tres capas
Cuando un programa se estructura sólo con estos tres tipos de objetos, es decir, que
todos los objetos que constituyen al programa pertenecen a uno de estos tipos de objetos, se
dice que se está utilizando un modelo de Tres Capas o de three tier.
Proceso de Análisis.
El proceso de análisis consiste en identificar los objetos dinámicos de un programa
y las relaciones dinámicas que guardan entre sí. El concepto de dinámico en contraposición
al persistente es: todo objeto o vínculo entre objetos cuyo tiempo de duración está acotado
por el tiempo que dure en ejecución el programa que los crea.
Este proceso establece los objetos dinámicos, su tipo, las relaciones que guardan entre
sí, y las clases de donde se originan. Como se están describiendo objetos dinámicos, se está
viendo al programa a tiempo de ejecución, lo que implica que es necesario establecer un
caso en ejecución para el programa, o sea, un escenario de ejecución.
Un escenario es una instancia de un caso, de tal manera que sigue todos los pasos
descritos por el caso, con valores reales de los intercambios de información entre el actor y
el programa. En términos generales puede establecerse que un escenario puede visualizarse
como un caso de prueba.
Definición de Escenarios
Para cada caso del modelo de requerimientos, se establecen sus escenarios los cuales
describirán instancias de los casos en modalidades normales, excepcionales y de error.
Cada escenario establecerá valores específicos para cada objeto definido en los pasos
de los casos, así como especificará de manera única cada acción del actor, de tal manera
que no existan opciones en la ejecución del caso.
Ejemplos de un escenario lo componen las siguientes partes:
Descripción del Caso
Descripción de los valores para cada paso del Caso.
Identificación de Objetos Interfaz
Para cada escenario, es necesario identificar los objetos con los que interactuará el
actor en primera instancia la transacción se inicia a través de la interacción y un objeto
interfaz. Notar que los únicos objetos con los que puede interactuar un actor son objetos
interfaz.
Identificación de Objetos de Negocio
Una vez identificado el objeto interfaz, existirán acciones del escenario que, debe
realizar apoyado en otros objetos para poder realizar el Caso dado por el escenario. Los
objetos sobre los que estará soportado un objeto interfaz serán objetos de negocio a los
cuales les estará solicitando servicios, ya sea para que hagan operaciones relacionadas con
el negocio o bien para la obtención de información de la base de datos.
Identificación de Objetos de Datos
Eventualmente los objetos de negocio necesitarán información procedente de la base
de datos, por lo que necesitarán solicitarle servicios de lectura o escritura de datos
persistentes a objetos de datos.
Diagrama de Colaboración
Para un escenario dado, se puede proceder a la identificación de los distintos tipos
de objetos apoyándose en una herramienta notacional: los diagramas de colaboración. Un
diagrama de colaboración describe a cada objeto identificado y la interfaz dinámica con
otros objetos, además el momento en el tiempo en que se da tal relación dinámica. La
notación de éstos diagramas en UML describe a los objetos en forma de rectángulos en
donde se indica además a la clase que pertenecen, con una línea recta uniendo a los objetos,
la asociación dinámica entre ellos, el mensaje que se envían junto con sus argumentos a
través de una flecha simple ligada a la asociación y la información que fluye por la interfaz
con una flecha que en un extremo tiene un pequeño círculo.
Modelo de Clases Dinámicas
Una vez que han sido identificados los objetos y sus asociaciones dinámicas con los
distintos diagramas de colaboración correspondientes a otros tantos escenarios, es necesario
especificar las clases a partir de las cuales se podrán crear tales objetos.
La especificación de esas clases constituye el modelo de clases dinámicas que darán
servicio al sistema. Estas clases estarán especificadas en un diagrama de clases, pero los
objetos que sean instancias de ellas, son objetos que tendrán un tiempo de vida limitado por
la duración de la ejecución del programa. Esta situación contrasta con el modelo del
dominio del problema en donde se describen principalmente las clases estáticas que
generan objetos persistentes.
En este modelo principalmente se definen los métodos de cada clase con toda la
información necesaria para su adecuada especificación, como las características indicadas .,
,
en la sección anterior.
Estas clases sirven principalmente para describir la funcionalidad del sistema para el
escenario dado. Las líneas punteadas indican qué objeto instanciará a cuál, esto es, que
objeto creará a otro.
2.4. PROGRAMA MINIMOS
CUADRADOS
2.4.1. DESCRIPCIóN DEL PROBLEMA
Se necesita elaborar un programa para mostrar la funcionalidad practica del principio de
Mínimos Cuadrados, donde se tiene una secuencia de muestras, y se desea encontrar el
valor de un conjunto de constantes calculada mediante la minimización del valor de una
función de Error Cuadrático.
2.4.2. MODELO DE ANALISIS DE REQUERIMIENTOS
1. Identificación de las Transacciones Núcleo
UC l . Captura de Datos
UC2. Modificación de Datos
UC3. Eliminación de Datos
UC4. Calculo de la función aproximada y gráfica
UC5. Cambio del Rango
2. Diagrama de Use Cases
Alumno
UC2. Modificación de Datos UC4. Calculo de la función aproximada y gráfica
Alumno
UC5. Cambio del Rango
3. Identificación de los pasos y casos más simples para cada Use Cace.
Q Alumno UC l . Captura de Datos
UC1. Captura de Datos
l . Alumno. Selecciona Nuevo en el menú Archivo o, presiona el botón Nuevo
2. Sistema. Despliega la pantalla de datos y resultados.
3. Alumno. En el menú función selecciona Insertar Puntos o, presiona el Botón
Insertar puntos o, presiona el botón derecho del ratón cuando el puntero esta sobre
la lista y selecciona Insertar puntos.
4. Sistema. Despliega la pantalla de Agregar Puntos
5. Alumno. Introduce una coordenada x,y en los campos correspondientes
6. Alumno. Presiona el botón Insertar
7. Sistema. Coloca el punto insertado en una lista
8. Sistema. Prepara el formulario para introducir otro punto
9. Se repiten los pasos 3 a 6 indefinidamente.
10. Alumno. Presiona el botón Salir o presiona la tecla Esc
1 l . Sistema. Cierra la ventana de Insertar Puntos
12. Sistema. Calcula el M máximo y prepara un ComboBox.
13. Fin
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio Insertar
f
L
Insertar
Agregar Puntos
t
Salir Ver Datos y Gráfico
En este caso no se
Datos y Gráfico 1 Modelo del dominio del problema.
e se identificarán los candidatos a clases estáticas debido a qu
considerará que el alumno no requiere guardar ningún tipo de dato.
Alumno UC2. Modificación de Datos
UC2. Modificación de Datos
l. Alumno. Selecciona un dato de la lista de datos.
2. Alumno. En el menú Funcidn selecciona Modzjkar punto o, presiona el botón
derecho del ratón cuando el puntero esta sobre la lista y selecciona Mudzjkar
punto o, hace doble clic en el dato de la lista que desea modificar.
3. Sistema. Despliega Pantalla de Modzjcacidn de datos
4. Alumno. Modifica los datos
5. Alumno. Presiona el botón Aceptar
6. Sistema. Modifica el dato de la lista.
7. Fin
Modelo de Interfaz
Diagrama de navegación de pantallas.
Inicio
f
\
Modificar Modifica Punto
Modificar
Salir
Punto
Menú Principal
Modelo del dominio del problema.
En este caso no se identificarán los candidatos a clases estáticas debido a que se
considerará que el alumno no requiere guardar ningún tipo de dato.
Q Alumno UC3. Eliminación de Datos
UC3. Eliminación de Datos
l . Alumno. Selecciona la coordenada que desea eliminar de la lista.
2. Alumno. Selecciona Eliminar punto el menú en el menú Funcibn o, presiona el
botón Eliminar punto o, presiona el botón derecho del ratón con el puntero sobre
la lista y selecciona Eliminar punto.
3. Sistema. Elimina la coordenada de la lista.
4. Fin.
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio
F f \
Menú principal \ 1
I 1 Elimina<
Salir
Modelo del dominio del problema.
En este caso no se identificarán los candidatos a clases estáticas debido a que se
considerará que el alumno no requiere guardar ningún tipo de dato.
A UC4. Calculo de la función aproximada Alumno y gráfica
UC4. Calculo de la función aproximada y gráfica
1. Alumno. Selecciona en valor para M
2. Alumno. Presiona el botón Graficar o, Selecciona Graficar en el menú función.
3. Sistema. Realiza el calculo de la función que pasa por los puntos utilizando el
método de Mínimos Cuadrados.
4. Sistema. Realiza el gráfico de los puntos introducidos y la función calculada.
5. Fin
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio Alecciona M + I
r f \
Datos y Gráfico Menú principal \
I ' GraficarL J
Salir
Modelo del dominio del problema.
En este caso no se identificarán los candidatos a clases estáticas debido a que se
considerará que el alumno no requiere guardar ningún tipo de dato.
Alumno UC5. Cambio del Rango
UC5. Cambio del Rango
1. Alumno. Presiona el botón Cambiar Rango o, En el menú Función selecciona
Cam biar Rango
2. Sistema. Despliega pantalla de Cambiar Rango
3 . Alumno. Hace los cambios necesarios al rango que aparece.
4. Alumno. Presiona el botón Aplicar o, presiona la tecla Enter.
5. Sistema. Adapta el gráfico de acuerdo con los datos introducidos.
6. Alumno. Presiona el Botón Cerrar o, presiona la tecla Esc.
7. Fin
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio I Cambiar n
Modificaciones
[-)=[-k/ Menú principal c Salir
Salir
Datos y Gráfico
Modelo del dominio del problema.
En este caso no se identificarán los candidatos a clases estáticas debido a que se
considerará que el alumno no requiere guardar ningún tipo de dato.
2.4.3. MODELO DE ANALISIS DINAMICO
UC1. Captura de Datos
1. Descripción del escenario correcto más simple
I PASO I DESCRIPCION ESCENARIO 1
Puntos o, presiona el Botón Insertar puntos o, Insertar Puntos Alumno. En el menú función selecciona Insertar 3
Sistema. Despliega la pantalla de datos y resultados. 2
Nuevo Alumno. Selecciona Nuevo en el menú Archivo o, presiona el botón Nuevo
I presiona e¡ botón derecho del ratón cuando el puntero I
esta sobre la lista y selecciona Insertar puntos. 4
Alumno. Introduce una coordenada x,y en los campos 5 Sistema. Despliega la pantalla de Agregar Puntos
6 Alumno. Presiona el botón Insertar 7 Sistema. Coloca el punto insertado en una lista 8 Sistema. Prepara el formulario para introducir otro
correspondientes
punto 9 Se repiten los pasos 3 a 6 indefinidamente.
I 10 I Alumno. Presiona el botón Salir o presiona la tecla I
Esc 11 Sistema. Cierra la ventana de Insertar Puntos
Sistema. Calcula el M máximo y prepara un ComboBox.
2 Alumno
2. Diagrama de Colaboración
Dato x = 3 Dato y = 3 Insertar
Dato x = 5, Dato y = h
Esc.
-b oIPrincipal oIHija 1. Nuevo clik()
3. Insertar-clik() 13. ActualizaCombo()
-b t 9. InsertaPunto(punto)
7. ValidaFlotante(x,result)
8. ValidaFlotante(y,result) __+
4. Show() -b - oIAgregar oNValidacion
5. TecleaDatos() -b
6. Ok clikp 1 l . Salir() -b 1 12. Unload()
3. Diagrama de Clases Dinámicas
cIPrincipal
<<event>>Nuevo-click()
<<event>> Insertarclick()
----c cIHi'a
Show()
ActualizaCombo()
InsertarPunto(punto)
ValidaFlotante(va
UC2. Modificación
<<event>> Salir()
de Datos
1. Descripción del escenario correcto más simple
I PASO I DESCRIPCI~N I ESCENARIO I 1 Modificar punto Alumno. En el menú Función selecciona Modzjcar punto
o, presiona el botón derecho del ratón cuando el puntero esta sobre la lista y selecciona Modzjcar punto o, da doble clic en el dato de la lista que desea modificar.
2 Sistema. Despliega Pantalla de Modzjcacidn de datos
I 1 3 Alumno. Modifica los datos Dato x = -1, Dato I " = 1 r"
4 Sistema. Modifica el dato de la lista. 5
Aceptar Alumno. Presiona el botón Aceptar
6 I Fin
2. Diagrama de Colaboración
2. SubMenuModificar-click() 3 . DespliegaDato(x, y) ___, 4 I oIPrincipal
5. ValidaFlotante(x,result)
oNValidacion Alumno
6. ValidaFlotante(x,result) +
l. SeleccionaDato() 7. ModificaPunto(punto)
8. Unload()
3. Diagrama de clase Dinámicas
DespliegaDato(x,y)
Show()
cIHi.ja
<<event>>SeleccionaDato()
<<event>> ModificaPunto(punto)
Unload()
I PASO
l 1
l 4
I I I I
I I
I ? I I I I I I
*-""A cNValidacion
ValidaFlotante(va1,result)
UC3. Eliminación de Datos
1. Descripción del escenario correcto más simple
DESCRIPCI~N Alumno. Selecciona la coordenada que desea eliminar de la lista.
Alumno. Selecciona Eliminar punto el menú en el menú Funci6n o, presiona el botón Eliminar punto o, presiona el botón derecho del ratón con el puntero sobre la lista y selecciona Eliminar punto. Sistema. Elimina la coordenada de la lista. Fin.
ESCENARIO El primero de la lista
Eliminar punto
2. Diagrama de Colaboración
x 2. SubMenuEliminar-click() oIPrincipa1
ll 3. Eliminapunto()
4. ActualizaCombo() Alumno
oIHija
1. SeleccionaDato()
3. Diagrama de clase Dinámicas
cIPrincipa1
<<event>> SubMenuEliminar - click() ""I")
UC4. Calculo de la función aproximada y gráfica
PASO 1 2
3
4
5
cIHi-ja
<<event>>SeleccionaDato()
Eliminapunto()
ActualizaCombo()
1. Descripción del escenario correcto más simple
DESCFUPCI~N ESCENARIO Alumno. Selecciona en valor para M Alumno. Presiona el botón Graficar o, Selecciona Graficar
M = 2
puntos utilizando el método de Mínimos Cuadrados. Sistema. Realiza el calculo de la función que pasa por los en el menú función.
Graficar
Fin función calculada. Sistema. Realiza el gráfico de los puntos introducidos y la
2. Diagrama de Colaboración
oIPrincipal
Qd 1. SeleccionaM() 1 3. Graficar() oNValidacion
ompletos(lista,M,ResIt)
Alumno 2. SMGraficar-Click()
3- 5. CalculaFuncion(lista,M,Y()) - 6 . DespliegaFuncion(Y(),M) \ -I oNMatematico 8. ImplementaEscala() 7. CalculaEscala(lista, minX,maxX,minY,maxY) 10. InseratCoordenadas(lista,dx,dy) 11. PintaError(Y(),M) 9. EvaluaFuncion(Xi,Y(),M,Result)
-
<<event>>SeleccionaM() I I I
I - 1
i
3. Diagrama de clase Dinámicas
<<event>>SMGraficar-click()
Graficar()
DespliegaFuncion(Y(),M)
ImplementaEscala()
InsertaCoordenadas(lista,dx,dy)
I PintaError(Y(),M) I
"-
cNValidación r"-"" I I I I VerificaDatosCompletos(lista,M,result) I I I I I I I I I I I
_"_.,
I I
cNMatematico
CalculaFuncion(lista,M,Y())
CalculaEscala(lista,minX,maxX,minY,maxY) """"I I"""
UCS. Cambio del Rango
1. Descripción del escenario correcto más simple
PASO Cambiar rango Alumno. Presiona el botón Cambiar Rango o, En el menú 1
ESCENARIO DESCFUPCI~N
Función selecciona Cambiar Rango 2
Derecho = 3 Izquierdo = -3, Inferior = -2 aparece. Superior = 2, Alumno. Hace los cambios necesarios al rango que 3
Sistema. Despliega pantalla de Cambiar Rango
4
Sistema. Adapta el gráfico de acuerdo con los datos 5
Aplicar Alumno. Presiona el botón Aplicar o, presiona la tecla Enter.
introducidos. 6 Cerrar Alumno. Presiona el Botón Cerrar o, presiona la tecla Esc. 7 I Fin
2. Diagrama de Colaboración
2. Show(L
7 oIPrincipal oNValidacion
0- l . MenuCambuar-Click() 5. Escala(minX,maxX,minY,maxY)
A - I ~l~~~~ 4. Aceptar-ClicKO
6. Graficar()
I I I 1 ___,
3. CalculaEscala(oIHija.Iista,minX,maxX,minY,maxY)
oNMatematico
3. Diagrama de clase Dinámicas
<<event>>MenuCambiar() I .
""_ """"""""_ Show()
I
_"_
Escala(minX,maxX,minY,maxY)
cNMatematico
CalculaEscala(oIHija.lista,minX,maxX,minY,maxY)
2.5. PROGRAMA SERIES DE
FOURIER
2.5.1. DESCRIPCIóN DEL PROBLEMA
Se necesita elaborar un programa para mostrar el comportamiento de la serie de Fourier al
considerar distintas cantidades de coeficientes al aproximar una función.
2.5.2. MODELO DE ANALISIS DE REQUERIMIENTOS
1. Identificación de las Transacciones Núcleo
UC1. Aproximar función y graficar
UC2. Cambiar rango
2. Diagrama de Use Cases
UC l . Aproximar función y graficar
Alumno
UC2. Cambiar rango
3. Identificación de los pasos y casos más simples para cada Use Cace.
A UC l . Aproximar función y graficar Alumno
UC l . Aproximar función y graficar
l . Alumno. Presiona el botón Nuevo o, Selecciona Nuevo en el menú Archivo.
2. Sistema. Abre la ventana para efectuar la aproximación.
3. Alumno. Escribe una ecuación en el campo correspondiente
4. Alumno. Selecciona en valor para el número de coeficientes
5. Alumno. Da un intervalo donde se efectuará la aproximación
6. Alumno. Presiona el botón Graficar o, en el menú Función selecciona Aproximar
Función
7. Sistema. Realiza la aproximación
8. Sistema. Grafica la Serie de Fourier calculada y la función original
9. Fin
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio
* Nuevo T \
Menú principal -J b Aproximación y Gráfica \ 1
Salir Salir
Modelo del dominio del problema.
En este caso no se identificaron los candidatos a clases estáticas debido a que se
considero que no es necesario que el alumno guarde algún tipo de dato.
n
Alumno x" UC2. Cambiar rango
UC2. Cambiar Rango
l . Alumno. Presiona el botón Cambiar Rango o, En el menú Funcidn selecciona
Cambiar Rango
2. Sistema. Despliega pantalla de Cambiar Rango
3. Alumno. Hace los cambios necesarios al rango que aparece.
4. Alumno. Presiona el botón Aplicar o, presiona la tecla Enter.
5. Sistema. Adapta el gráfico de acuerdo con los datos introducidos.
6. Alumno. Presiona el Botón Cerrar o, presiona la tecla Esc.
7. Fin
Modelo de interfaz.
Diagrama de navegación de pantallas.
Inicio Modificaciones
I Salir Salir c I Aproximación y Gráfica I
Modelo del dominio del problema.
En este caso no se identificarán los candidatos a clases estáticas debido a que se
considerará que el alumno no requiere guardar ningún tipo de dato.
2.5.3. MODELO DE ANALISIS DINAMICO
UC1. Aproximar función y graficar
1. Descripción del escenario correcto más simple
f PASO I DESCRIPCI~N ESCENARIO
función original 9 Fin
2. Diagrama de Colaboración
7. VerificaDatos(funcion,n,Xl ,X2,result) +
I oNGram
I 8. EsValida(funcion,result)
9. CombierteCad(cadena,post)
1. Nuevo-click( oNEvalFun
16. Evalgost(post,Xi) 2. Show()
A 4. LlenaDatosO I Alumno
5. Graf-click()
- I oIFrir
IO. CalculaCoef(ao,an(),bn(),n) 4P al oNlntergra I 3 . LlenaCornboO
6. GraficarO 15. Serie(ao,an(),bn(),post(),intervalo,n)
1 1 . VisualCoef(ao,an,bn,n) 12. CalculaEscala(Xl,X2)
13. Cuadricula()
14. PintaEjes()
oNEvalFour
3. Diagrama de Clases Dinámicas
<<event>>Nuevo-Click()
l .- I
cIFrir
<<vent>>LlenaDatos()
<<vent>>Graficar-Click()
Show()
Llenacombo()
Graficaro
VisualCoef(ao,an,bn,n)
CalculaEscala(X 1 ,X2)
Cuadricula()
PintaEjesO
cNValida - - - - - - - -
I I I I I I I
I I I
cNEvalFun
CombierteCad(cadena,post) EsVaIida(hncion,result)
Eval-post(post,Xi)
"""
""
cNEvalFour
Serie(ao,an(),bn(),post(),intervalo,n)
UC5. Cambio del Rango
1. Descripción del escenario correcto más simple
1 PASO
P-
Alumno. Presiona el botón Cambiar Rango o, En el menú Función selecciona Cambiar Rango Sistema. Despliega pantalla de Cambiar Rango Alumno. Hace los cambios necesarios al rango que aparece. Alumno. Presiona el botón Aplicar o, presiona la tecla Enter. Sistema. Adapta el gráfico de acuerdo con los datos introducidos. Alumno. Presiona el Botón Cerrar o, presiona la tecla Esc. Fin
ESCENAFUO Cambiar rango
Superior = 2, Inferior = -2 Izauierdo = -3. Derecho = 3 Aplicar
Cerrar
2. Diagrama de Colaboración
l . CambiarRango - Click()
5. Escala(minX,maxX,minY,maxY)
+ oNValida 3. Modifica() + 4. Aplicar() 6. GraficarDadoO
____+ oIFrir
3. Diagrama de Clases Dinámicas
Escala(minX,MaxX,minY,maxY) I I I
cICambiarRango """_
<<event>> Aplicar() GraficarDadoO
Una vez mostrado el diseño de dos de los programas se presentará la metodología
utilizada para la elaboración de las ayudas de los programas.
El desarrollo de las ayudas se realizó con un software de la familia de Microsoft Visual
Studio 6, un programa llamado Help Workshop.
Para poder dotar de un sistema de ayuda a las aplicaciones, se necesitan básicamente
tres elementos: un editor donde escribir el texto de la ayuda (que debe ser almacenada en
formato RTF); un compilador de ayudas, generalmente el Help Workshop de Microsoft; y
el programa WINHELP, que será el encargado de visualizar el contenido de la ayuda. El
editor más utilizado para crear los ficheros de texto de ayuda es Word, aunque puede usar
cualquier otro editor que soporte el formato RTF ya que el compilador de ayudas solo lee
dicho formato. Aunque en Windows existe un editor, llamado Word Pad, que facilita la
creación de archivos en formato RTF.
Un archivo de texto en formato RTF no es directamente utilizable como ayuda en
Windows, sino que es necesario compilarlo para generar un archivo de ayuda. De hecho un
archivo de ayuda puede incluir múltiples ficheros de texto en formato RTF.
Se creó un primer archivo de ayuda de prueba como sigue:
Primeramente se creó en Word un archivo con unas cuantas líneas de texto sin
gráficos, enlaces ni nada parecido. Posteriormente se guarda el archivo en disco en formato
RTF. Enseguida se crea en Help Workshop un archivo de proyecto que es un fichero de
texto ASCII, que contiene indicaciones acerca de opciones de compilación, nombres de
archivo, etc. En este archivo pueden aparecer múltiples apartados, comenzando cada uno de
ellos con un título entre corchetes. El apartado [FILES], estará seguido de una lista de los
nombres de archivo que componen nuestro sistema de ayuda. Esto se puede hacer en el
compilador de ayudas de la siguiente manera:
Al ejecutar esta aplicación aparecerá una ventana vacía. Pulsar Ctrl+N o seleccionar
la opción New del menú File con el fin de crear un nuevo archivo, facilitando un nombre
para él. A continuación pulsar el botón Files que hay en la derecha, haciendo aparecer la
ventana de archivos, pulsar el botón Add y seleccionar el archivo en formato RTF.
En la siguiente figura se muestra un ejemplo de lo explicado anteriormente.
El siguiente paso se da con la compilación del proyecto, para lo cual basta pulsar el
botón que hay en la esquina inferior derecha, llamado Save and Compile.
Efectuada la compilación aparece un nuevo archivo de ayuda que contiene el texto
del archivo original. Se puede ver el contenido de este archivo simplemente pulsando el
último botón del Help Workshop, que se encargará de ejecutar el programa Winhelp
abriendo el archivo de ayuda generado.
Una vez que se hizo el proceso anterior se obtuvo un archivo de ayuda muy simple,
enseguida se verá como hacer un archivo de ayuda con varias páginas ya que en la realidad
las ayudas de las aplicaciones son mucho más complicadas. Podemos crear varias páginas
en la ventana de ayuda, de tal forma que se acceda a una u otra mediante una opción,
similar a un botón o menú. Para ello lo primero que se tiene que hacer es escribir las
páginas de texto, separando cada una de la anterior por un salto de página manual, que
conseguiremos pulsando Ctrl+Enter. Al compilar este nuevo archivo se genera un archivo
de ayuda dividido en varias páginas, el problema ahora es encontrar la forma de acceder a
cada una de las páginas.
Para permitir que el usuario seleccione cualquiera de las páginas de nuestro archivo
de ayuda se tienen que hacer dos cosas: primero, asignar a cada página un identificador que
deberá ser Único, es decir, no podrán existir dos páginas con el mismo identificador;
segundo, facilitar desde la página inicial unos enlaces que permitan saltar a las otras
páginas.
Se comienza por asignar a cada una de las páginas su identificador. Situando el cursor
en el comienzo de la página, a la izquierda del título, e insertando una nota al pie de página.
Para hacer esto con Word se tiene que abrir el menú insertar y seleccionar nota al pie. En
dicha ventana hay que introducir una marca personal, un carácter #, que indicará al
compilador de ayuda que lo que sigue es un identificador. Después de pulsar ENTER se
abrirá un panel en la parte inferior de la ventana de Word, en la que se puede introducir el
identificador correspondiente. Este procedimiento se repite para cada una de las páginas.
Una vez que cada una de las páginas del sistema de ayuda tiene un identificador
Único, se tiene que facilitar en la página inicial o la primera página, unos enlaces que
permitan saltar a las otras páginas. Esto se hace de la siguiente forma:
Escribir en la página de inicio los títulos y textos que actuarán como enlaces para
saltar a cada una de las páginas. A cada título seleccionarlo uno por uno y en el formato de
la fuente elegir doble subrayado, este texto servirá como enlace pero hay que indicarle a
que página debe saltar. Para ello se le pone a continuación de cada título, sin dejar espacio
alguno, el identificador de la página a la que debe saltar. Puesto que esta información no
debe ser visible para el usuario se le da el atributo de oculto, esto se hace desde Word,
seleccionando el texto correspondiente al identificador y dando el atributo de oculto.
Ya que se ha trabajado en la programación con Visual Basic, se busca la forma de
asociar un proyecto de Visual Basic con el archivo de ayuda, una vez hecho esto la ayuda
aparece en nuestro programa tan solo con oprimir la tecla F1, sin embargo siempre
aparecerá la primera página del archivo de ayuda lo cual no tiene mucho sentido, ahora el
objetivo es tener un archivo de ayuda tal que la página que se muestre dependa del estado
actual del programa, a este tipo de ayuda se le conoce como ayuda sensible al contexto.
Para esto se estudió la forma de relacionar los controles de Visual Basic con las
páginas del fichero de ayuda, se ha encontrado que Visual Basic relaciona cada uno de sus
controles con un identificador numérico, sin embargo los identificadores del archivo de
ayuda no son solo numéricos, también encontramos identificadores como cadenas de
caracteres. Este problema se solucionó al estudiar una de las características del compilador
de ayuda, esta es pulsando el botón MAP. Al hacerlo aparece una ventana como la que se
muestra enseguida.
Instead of IDH-, check there prefixes: x
En esta ventana se enumeran cada uno de los identificadores que se han asignado a
las páginas con un valor numérico, de esta forma cada página tiene dos identificadores, una
cadena y un número. La prueba de este tipo de ayudas se puede ver en los programas
desarrollados en donde la página de ayuda que se mostrará depende del contexto en el que
se encuentre el programa; por ejemplo, si en algún programa estamos escribiendo la
expresión o función, sobre la cual se harán operaciones, y se oprime la tecla F1, se mostrará
en la ayuda la página correspondiente a la escritura de la función.
Por último en el diseño de las ayudas se verá como insertar una imagen en el texto, ya
que muchas veces es necesario tener una imagen para poder explicar mejor algún tema. Lo
primero que hay que hacer es preparar las imágenes, que se quieren mostrar en la ayuda,
con la ayuda de algún editor de imágenes, guardarlas en formato BMP o meta archivos
WMF. Después de tener listas las imágenes se pueden insertar en nuestro archivo de texto
directamente ya que Word lo permite, sin embargo, es mejor insertar una referencia a la
imagen ya que el tamaño del archivo será menor y no tendremos problemas al compilarlo.
Para insertar la referencia a un gráfico en el archivo de texto, se disponen al principio
de una línea y entre llaves uno de los comandos que se muestran en la siguiente tabla,
seguido de un espacio y el nombre del archivo que contiene el gráfico.
Comando Elgráfico se inserta Bmc Centrado en la ventana de avuda Bml
A la derecha, con el texto a la Bmr
A la izquierda, con el texto a la derecha
izauierda
Las ayudas de los programas están hechos de esta forma, por lo cual los resultados se
pueden ver verificando los programas o ejecutando el archivo de ayuda directamente que se
encuentra en el subdirectorio en el que se instaló el programa.
I 4. CREACIóN DE UN DOCUMENTO EN ADOBE ACROBAT 1
En este punto, lo más laborioso fue editar todo el curso en algún procesador de textos,
pues es un trabajo lento y muy pesado.
La distribución que se le dió al documento fue la de colocar Bookmarks para
colocar el visor de Acrobat Reader en el temario de cada unidad, y crear links del temario
al desarrollo del tema. Esta distribución es muy similar a la que se le dió al documento
principal en HTML para tener consistencia en la estructura de los documentos para este
curso.
Gracias a las herramientas conseguidas, la conversión del curso a documento PDF
para Acrobat Reader no fue muy complicado, ya que al instalar el paquete, coloca una
utilería para imprimir el documento en un archivo con el formato PDF.
A continuación se mostrará como se realizan algunas de las funciones más
importantes del paquete.
Creación de un Bookmark
Mediante este proceso se puede navegar por todo el documento, sólo debemos pulsar
el Bookmark, y nos llevara a la sección definida.
l . Colocar el visor en el lugar donde queremos poner el enlace al Bookmark.
2. Debemos seleccionar Show Bookmarks en el menú Window.
94
3. Dar clic con el botón derecho del ratón sobre el espacio de los Bookmarks y
seleccionar New Bookmark.
4. Dar un nombre al Bookmark creado.
Creación de un Link
Esta utilería es un tanto parecida a la anterior, la diferencia es que se hace una liga
sobre el documento y no en un árbol que es visible todo el tiempo.
l . En la barra de herramientas se debe seleccionar link tool.
2. Encerrar en un recuadro el elemento que funcionará como link.
3. Colocar el visor en la página hacia donde se desea hacer el link.
4. Seleccionar las propiedades adecuadas en el dialogo que aparece.
5. Presionar el botón Set Link.
Modificación de detalles en el texto
Con esto se podrá cambiar las propiedades del texto como son tipo de letra, tamaño,
grosor de línea, color, etc.
l . En el submenú TouchUp del menú Tools, seleccionar Text Attributes
2. En la barra de herramientas seleccionar TouchUp Text Tool
3. Seleccionar el texto que se desea modificar.
Menú Document
Este menú es uno de los más importantes dentro de la herramienta, pues cuando los
cambios en un documento son demasiados, es más practico cambiar toda la página que
modificarla línea por línea, además de poder reemplazar páginas; se pueden agregar otras
mas, o eliminar completamente.
Cambiar el orden de las páginas
Esta utilería es muy importante, pues en ocasiones cometemos errores al insertar
nuevas páginas en el documento que estamos creando, por lo que puede ser más fácil
cambiar el orden dentro del documento, que repetir el proceso de importación. Para este
proceso se deben seguir los siguientes pasos:
l . En el menú Window seleccionar Show Thumbnails.
2. En el lado izquierdo aparecen las páginas en miniatura
~~
3. Arrastrar las páginas miniatura de acuerdo con el orden que deseamos obtener.
5.- INTEGRACION FINAL DEL SITIO WEB.
Hasta este punto se ha indicado de que forma se han desarrollado cada una de las partes del proyecto, sin embargo, en seguida se muestra como se han integrado cada una de estas partes para formar un proyecto integral encaminado a la docencia, cumpliendo con los objetivos del proyecto; finalmente veremos como ha quedado terminada la página Web y de que forma cada una de las partes del proyecto se relacionan con el objetivo de que el alumno aproveche al máximo estas herramientas.
Una vez indicada la forma en la que se han desarrollado las páginas Web, indicando los detalles, se verá la estructura del sitio y el aspecto que las páginas tienen finalmente; en general el sitio Web consiste en varias páginas, el tamaño de cada página es limitado, ya que de esta manera se puede navegar a través del sitio de una forma rápida, considerando procesadores relativamente lentos.
La página de bienvenida es una página con marcos, dividida en tres partes, mediante esta estructura es más fácil la navegación en el sitio ya que en la parte izquierda está siempre visible en donde hay botones que nos llevan a las páginas más importantes del sitio, la siguiente imagen presenta la página de bienvenida.
Bienvenido, alumno, al curso de comunicaciones I
OBJETIVOS:
- Que el alumno conozca y maneje los conceptos matemátlcos escenciales para las comunlcalones.
- Que el alumno conozca y manele los conceptos fundamentales de la teoría de las comunlcaciones analóglcas
..- -,, ,. ,
ACERCA DE:
Este sitlo web, con todas sus utilerías, Programas, vldeos, PDF's, e t c . . , fueron desarrollados como proyecto terminal, uno de los principales objetivos es que esta página sea una herramienta más para ti . los temas que se desarrollan aqul contienen información extra que te puede selvir para entender mejor los conceptos vistos en c lase. Los programas se desarrollaron en Visual Basic, estos te sewirán para simular algunos ejemplos y así puedas comprender mejor el tema que estés estudiando, esperarnos que esta utllería te s e a de gran ayuda.
, I
Una característica de esta página es que se puede modificar el tamaño de los marcos con solo arrastrar el ratón desde la línea del marco hasta el tamaño que se desee con el botón izquierdo presionado, es decir, los marcos son modificables para la comodidad del usuario, por ejemplo, si el usuario desea reducir o eliminar el marco superior lo puede hacer y la página se vería como en la figura siguiente:
1 O0
La parte izquierda de la página presenta botones, el botón Temario muestra una página que contiene el temario general del curso, Los botones UnidadX muestran en la parte derecha el temario detallado de la unidad X, por ejemplo, si se da clic en el botón Unidad 11, el resultado es el siguiente:
UNIDAD I I . 1
Los temas y sub temas que se muestran en cada página de temarios contienen un enlace al tema o sub tema correspondiente, por ejemplo, si en la página de la figura anterior se da un clic al sub tema 2.2.1 ., el resultado será el siguiente:
101
Estas son las páginas de los temas, cada una de estas páginas tiene al final un enlace que regresa al temario de la unidad que corresponde, por ejemplo, el enlace de esta página regresa al temario de la unidad 11.
También se tiene una página de utilerias, para llegar a esta, se debe dar clic en el botón correspondiente, cuyo texto es "Utilerias", no se visualiza en las imágenes ya que se encuentra en la parte inferior de la página de botones. El aspecto de la página es el siguiente:
I.JTILEFU4S.
En seguida te presentamos una serie de programas que heron desarrollados para ayudarte en el entendmuento de la matena, descargalos e instalalos en tu PC, primero descarga e instala el programa graficador ya que este tiene los archvos necesanos para que los demás funcionen, esto se hlzo así ya que el programa con todos los controladores ocupa demasiado espacto, por lo tanto los demás programas ocupan menos espacloy son más ráppldos de descargar
E ' r o c ~ m a C+&c adw
E?humos cua'lr ;t,:k<s i1ksreto)
l v h ~ o s c~uadrados (C'mtuluo)
Como se puede ver, esta página contiene una serie de enlaces que nos llevan a diferentes partes del proyecto, es aquí en donde se ve la relación existente entre todas las partes del proyecto. el primer enlace se encuentra en el botón y con tal enlace los alumnos
102
inscritos en el curso pueden verificar sus calificaciones, la página de calificaciones se ve de la siguiente manera:
Calificaciones de los parciales
En esta pagina puedes consultar tus calificaciones, solo tienes que dar tu nomhre conlpleto rnnlrnzandn ron e1 apellido patenln, matwno y nomhreis), hl mamrula y 01 HFC, ron letras ntayusculas s e g u n sea el caso.
En esta página uno puede ingresar tus datos como son: Nombre, Matrícula y RFC, todos los datos debes escribirlos con letra mayúscula, una vez escritos los datos y una vez que se está seguro que los datos son correctos se oprime el botón "Buscar Nombre", de esa forma se obtiene el resultado de la consulta, un ejemplo de esto se presenta en seguida.
Ft 9,
L.'. .$I I Buscar Nombre I
I ' I
Oprimiendo el botón antes mencionado se obtiene el siguiente resultado:
I o3
El resultado de una consulta SQL regresó los datos que interesaban al alumno, la base de datos solo puede ser alterada por el administrador del sitio, en este caso el profesor de la materia. Con lo anterior se vio la relación existente entre el sitio HTML, las páginas ASP y JavaScript, ya que para el desarrollo de dichas páginas fueron necesarias las tres partes mencionadas.
Regresando a la página de utilerias, se procede con una explicación correspondiente a los siguientes enlaces.
En segwda te presentamos una sene de programas que fueron desarrollados para ayuc en tenhento de la matena, descargalos e instalalos en tu PC, pnmero descarga e mstala el programa grdcador ya que este bene los archvos necesanos para que los demás funcionen, esto se h o así ya ,que el programa con todos los controladores ocupa demasiado espaclo. por lo tanto los demás programas ocupan menos espacloy son más ráppldos de descargar
Promama Crnficador
l . , h o s cua.ltados (Dtscreto)
ldinimos cuadrados i'Ihntinuo)
Senes de FWUIPI-
Gmvo1ucli.n
Tt-ansfornlada ,de F,mrler 2
Mcdulador A Id A
Estos enlaces corresponden a los programas desarrollados en VB6 (Visual Basic t cada uno de ellos a un programa, los nombres de los enlaces son muy ilustrativos, por cual no es necesario explicar cada enlace, lo Único que se tiene que hacer es dar clic en
9 ,
lo el
104
enlace correspondiente al programa que deseas descargar, guardarlo en disco, descomprimirlo en algún subdirectorio que se tenga bien ubicado e instalarlo, el proceso de instalación es muy sencillo, solo da clic en el icono nombrado setup y se abrirá la siguiente ventana:
Da clic en el botón OK, después en el icono de instalación, puedes elegir un subdirectorio en el que se instalará el programa, da aceptar a las siguientes opciones y el programa se instalará completamente en tu computadora, cada programa contiene su propia ayuda, en la cual se te indica como utilizar el programa, en general las ayudas son muy sencillas y prácticas ya que te muestran imágenes que corresponden al programa en uso y una explicación muy concisa sobre como usar el programa, todos los programas se manejan esencialmente de la misma forma, esto se debe a que fueron diseñados de la misma manera mediante el uso de UML. Aquí se tiene una vez más relación entre las distintas partes del proyecto, en este caso entre HTML. UML, Visual Basic y el diseño de ayudas. Por ejemplo el aspecto del programa graficador es el siguiente:
105
Muestra la Gráfica de la función antes escrlta
El ultimo de los enlaces en la página de utilerias corresponde a los apuntes de comunicaciones I en formato PDF, los cuales puedes descargar y consultar utilizando el programa Acrobat Reader, con estos apuntes se tiene la finalidad de que al alumno le sea más fácil acceder a la información correspondiente al curso, con esto se ha presentado una guía rápida de cómo usar el sitio y las utilerias desarrolladas para el complemento del mismo, también se ha visto como cada una de las partes del proyecto se relacionan entre sí para formar este sitio Web integral para la docencia “on-line”.
106
CONCLUSIONES
Durante este proyecto hemos aprendido conceptos muy importantes acerca del diseño de
una página Web, ahora sabemos que el sitio construido sirve como introducción a proyectos
más complicados, donde la interacción con el usuario es mucho más dinámica, es decir, se
pueden hacer programas para ejecutarse directamente en el explorador, y no sólo dejar un
enlace a un programa para descargar, lo que implica ahorro de tiempo, pues el tiempo de
descarga depende del tamaño del programa, y los componentes que utilice.
En este proyecto logramos hacer una utilería dinámica, donde el alumno puede
consultar sus calificaciones en forma privada, este tipo de página se ejecuta en el servidor.
Esta página es muy dependiente de la capacidad del servidor, si las solicitudes a esa página
fueran muy grandes, el servidor sería insuficiente para ejecutar tantas veces un
procedimiento, por lo que la búsqueda de otras alternativas es indispensable.
Durante la construcción de este sitio pusimos en practica los conceptos de orientación
a objetos, siendo muy importante, ya que estas de metodologías son las mas utilizadas por
los grandes diseñadores de sistemas de computo, y es la base de los sistemas más robustos,
debido a que implica una documentación muy estricta, un nivel de encapsulamiento muy
alto, una gran cohesión y un bajo acoplamiento.
Además de todo lo anterior asimismo se puso en practica conceptos teóricos de
computación muy importantes como es la definición de gramáticas para el reconocimiento
de ecuaciones matemáticas y concretizar estructuras de datos para evaluar ecuaciones
complejas en su estructura.
Todos esta herramientas en conjunto han logrado la creación de un sitio Web muy
grande, robusto y con muchas ventajas para el usuario final debido a que no necesita tener
conocimientos muy avanzadas en cuanto a informática se refiere, solo necesita tener ganas
de aprender y conocer la forma de navegar en Internet, ya que el objetivo principal de un
curso es que el alumno aprenda, y no meterlo en líos dejando de un lado el curso.
107
Una de las grandes ventajas de este tipo de proyectos es que nunca terminan, ya que
siempre aparecen nuevas tecnologías para complementar lo anteriormente construido, ya
sean paquetes interactivos, multimedia o para aumentar la velocidad del sitio Web, y que se
puede complementar mostrando al publico usuario la ultima y mejorada versión del sitio.
En este proyecto se comprendió la importancia de la educación a distancia ya que este
sitio Web puede ser consultado desde cualquier parte del mundo siendo solamente
necesaria una PC y una conexión a Internet, donde este último es uno de los medios de
comunicaciones que han tomado impulso en los últimos años y que en terminos de
investigacion y educacion es muy importante.
Todo lo anterior ha servido como practica e introducción para entender sistemas
mucho más complejos, donde podríamos conjuntar sistemas de información y sistemas
dinámicos para lograr interpretar y manipular abstracciones de la realidad, hechos para
ejecutarse en una red de conlputadoras y de una manera eficiente.
108
BIBLIOGRAFIA
http://ptolenw.eecs.berkeley.edu
http:/lwww.aeocities.com/gustavoay/
http://www.webviva.condbiblioteca/
http://asp.programacion.net/
http://www2.interplanet.es/
Paul Kooros and Michele De Wolfe. JavaScript Prima Publishing, 1996.
Francisco Charte Ojeda. Programación con Visual Basic 6 Anaya multimedia, 1998.
Herbert Schildt. Aplique Turbo C++ para Windows McGraw Hill, 1993.
Aaron M. Tenenbaum, Yedidyah Langsam y Moshe A. Estructuras de datos en C Prentice Hall, 1993.
Sanchez López Rebeca Alicia (Traductora) Adobe Acrobat 4. O Adobe y Pearson Education, 2000
Alfred V. Aho, Ravi Sethi, Jeffrey D. Ullman Compiladores Principios, Técnicas y Herramientas Addison-Wesley
109
Jhon E. Hopcroft, Jeffrey D. Ullman Inlroduccicin u la Teoríu de Autómatas, Lengucjes y Computación. Cecsa
Gray Cornel1 The Visual Basic J,f¿)r Windows 95 Handbook Osborne McGraw Hill
Luis Fernando Castro Careaga Andisis y Diseño Orienludo u Objetos
Aplicado u Sisternus de Inf¿)rmucicin
I10