UNIVERSIDAD VERACRUZANA

UNIVERSIDAD VERACRUZANA
Facultad de Contaduría y Administración
“SISTEMA DE PROGRAMACIÓN ACADEMICA DE LA FACULTAD DE
CONTADURIA Y ADMINISTRACIÓN BAJO EL ENFOQUE DE DISEÑO Y
PROGRAMACIÓN DE SISTEMAS”
TESINA
QUE PARA ACREDITAR
LA EXPERIENCIA RECEPCIONAL
DEL PROGRAMA EDUCATIVO DE:
LICENCIADO EN SISTEMAS COMPUTACIONALES
ADMINISTRATIVOS
PRESENTA
JUAN ANTONIO CHIÑAS MATA
DIRECTOR DE TRABAJO RECEPCIONAL:
DRA. PATRICIA MARTINEZ MORENO
COATZACOALCOS VER., A 3 DE ENERO 2012
DEDICATORIA
DIOS
Porque fue el creador de todas las cosas, el que me ha dado fortaleza para continuar
cuando a punto de caer he estado. Porque me ha otorgado la oportunidad de vivir y
bendecirme con una familia extraordinaria. Porque hasta el día de hoy me ha
proporcionado llegar a este punto gozando de buena salud para alcanzar y conquistar
cada uno de mis objetivos, regalándome su inmenso e infinito amor y bondad. Por todos
y cada uno de los triunfos y tiempos de dificultad que me ha otorgado en los cuales he
aprendido a amarlo más.
Papá
A ti por haber sido un gran ejemplo en mi vida, sabiéndome brindar todo el apoyo que
uno puede imaginar, todo el amor que de tu corazón podía emanar, la comprensión que te
caracterizaba y el esfuerzo que me impulsabas aún cuando llegabas agotado. Es por eso
que hoy, este trabajo es para ti, donde quiera que estés, sé que estarías orgulloso. Te lo
dedico con mi corazón.
Mamá
A ti por haberme dado la vida y estar en todo momento conmigo, por infundirme ese
ánimo para seguir estudiando y creer en todo momento en mí. Aunque hemos pasado por
momentos difíciles, siempre has estado apoyándome y brindándome todo tu amor.
Porque te entregas sin esperar nada a cambio, por ese gran ejemplo de valentía para
enfrentar toda adversidad, esa constancia para continuar en esta vida siguiendo hacia
adelante y nunca darte por vencida. Es por eso que este trabajo, que me ha llevado
meses prepararlo, es para ti, por brindarme todo tu apoyo, retribuyéndote lo que me has
dado desde un principio.
Hermanos
A mis hermanos por estar en todo momento cerca de mí ayudándome e impulsándome
cuando las ganas me hacían falta. Por ese apoyo y cariño que me regalan y que espero
que siga uniéndonos. Este trabajo también va para ustedes, para que puedan ver, que
cuando algo se propone, sí se puede alcanzar.
AGRADECIMIENTOS
DIOS
Te doy gracias por estar siempre conmigo, por cada una de tus bendiciones a mi vida, por
ser la luz en mi camino. Por ser mi mejor amigo en todo momento, mi fortaleza cuando me
siento abatido y por la oportunidad de continuar en esta vida. Gracias Dios.
A MI PAPÁ
Por todas y cada una de las enseñanzas que supiste brindarme, por las experiencias que
me compartías para instruirme. Por tu apoyo incondicional en todo momento. Gracias
porque esos año en que tuve la dicha de disfrutarte y aprender de ti. Gracias Papá.
A MI MAMÁ
Por toda tu humildad y entrega que me ha enseñado tanto, por estar siempre conmigo,
apoyándome en todo lo que necesitaba para que pudiese salir adelante. Por velar en todo
momento para que nada me hiciese falta. A ti te debo todo, horas de consejos, de
regaños, de disciplinas, de tristeza y de alegría, de las cuales estoy muy seguro hoy en
día, las has aportado con todo el amor que te caracteriza, para forjar en mi un ser integral
y que hoy me siento orgulloso de lo que soy. Gracias Mamá, te amo.
A MIS HERMANOS
Gracias a ustedes mis hermanos, quienes siempre han estado a mi lado, compartiendo
todos esos secretos y aventuras que solo se viven entre hermanos. Por esas peleas que
nos han ayudado a madurar y aprender a apoyarnos más. Gracias.
A MIS AMIGOS
Que siempre han estado allí en los momentos que más los he necesitado. Por esa mano
dispuesta a levantarme cuando he sentido desfallecer, por ese apoyo incondicional, por
esa sincera y entrañable amistad que me han sabido brindar. A esos amigos que siempre
me han acompañado y con los cuales he contado desde que los conocí, no menciono
nombres, pues la lista es extensa y no quisiera dejar a nadie fuera de ella. Les digo de
todo corazón: ¡Gracias!
CAPITULO 1 ........................................................................................................................................................ 7
1.1 INTRODUCCIÓN....................................................................................................................................... 8
1.2 PLANTEAMIENTO DEL PROBLEMA .......................................................................................................... 9
1.3 JUSTIFICACIÓN ...................................................................................................................................... 10
1.4 OBJETIVO GENERAL .............................................................................................................................. 11
1.5 OBJETIVOS ESPECÍFICOS ....................................................................................................................... 11
1.6 LIMITACIONES ....................................................................................................................................... 11
1.7 DELIMITACIONES .................................................................................................................................. 12
CAPITULO 2 ...................................................................................................................................................... 13
INTRODUCCIÓN .......................................................................................................................................... 14
2.1 EL CICLO DE VIDA DEL DESARROLLO DE SISTEMAS ............................................................................... 15
2.2 IDENTIFICACIÓN DE PROBLEMAS, OPORTUNIDADES Y OBJETIVOS ...................................................... 15
2.3 DETERMINACIÓN DE LOS REQUERIMIENTOS DE INFORMACIÓN ......................................................... 17
2.4 ANÁLISIS DE LAS NECESIDADES DEL SISTEMA....................................................................................... 18
2.5 DISEÑO DEL SISTEMA RECOMENDADO ................................................................................................ 19
2.6 DESARROLLO Y DOCUMENTACIÓN DEL SOFTWARE ............................................................................. 20
2.7 PRUEBA Y MANTENIMIENTO DEL SISTEMA .......................................................................................... 20
2.8 IMPLEMENTACIÓN Y EVALUACIÓN DEL SISTEMA ................................................................................. 21
2.9 IMPACTO DEL MANTENIMIENTO .......................................................................................................... 22
2.10 PROGRAMACIÓN ................................................................................................................................ 23
2.10.1 ANTECEDENTES .......................................................................................................................... 23
2.10.2 HISTORIA .................................................................................................................................... 23
2.10.3 OBJETIVOS DE LA PROGRAMACIÓN ........................................................................................... 25
2.11 CLASIFICACIÓN LENGUAJES DE PROGRAMACIÓN .............................................................................. 26
2.11.1 PRIMERA GENERACIÓN .............................................................................................................. 26
2.11.2 SEGUNDA GENERACIÓN ............................................................................................................. 27
2.11.3 TERCERA GENERACIÓN .............................................................................................................. 27
2.11.5 QUINTA GENERACIÓN ................................................................................................................ 29
2.12 PROGRAMAS Y ALGORITMOS ............................................................................................................. 30
2.12.1 PROGRAMACIÓN ESTRUCTURADA ............................................................................................. 31
2.12.2 ORÍGENES DE LA PROGRAMACIÓN ESTRUCTURADA ................................................................. 32
2.12.3 ESTRUCTURA SECUENCIAL ......................................................................................................... 32
2.12.4 ESTRUCTURA SELECTIVA O DE SELECCIÓN ................................................................................. 33
2.12.5 ESTRUCTURA ITERATIVA ............................................................................................................ 35
2.12.6 VENTAJAS DE LA PROGRAMACIÓN ESTRUCTURADA ................................................................. 37
2.12.7 INCONVENIENTES DE LA PROGRAMACIÓN ESTRUCTURADA ..................................................... 38
2.13 PROGRAMACIÓN MODULAR .............................................................................................................. 39
2.14 PARADIGMA POR EVENTOS ................................................................................................................ 40
2.14.1SISTEMAS GUI ............................................................................................................................. 40
2.14.2 SISTEMAS CLIENTE-SERVIDOR .................................................................................................... 41
2.14.3 SISTEMAS DE MENSAJES ............................................................................................................ 41
2.14.4 CARACTERÍSTICAS DEL PARADIGMA ORIENTADO A EVENTO .................................................... 42
5
2.15 PROGRAMACIÓN ORIENTADA A OBJETOS .......................................................................................... 43
2.15.1 ANTECEDENTES .......................................................................................................................... 44
2.15.2 CONCEPTOS FUNDAMENTALES .................................................................................................. 45
2.15.3 CARACTERÍSTICAS DE LA POO .................................................................................................... 47
2.16 PROGRAMACION DE APLICACIONES WEB .......................................................................................... 50
2.16.1 DEFINICIÓN................................................................................................................................. 50
2.16.2 GENERALIDADES DE LA PROGRAMACIÓN WEB ......................................................................... 52
2.16.3 LENGUAJE HTML ........................................................................................................................ 52
2.16.4 LENGUAJE JAVASCRIPT ............................................................................................................... 54
2.16.5 LENGUAJE PHP ........................................................................................................................... 54
2.16.6 LENGUAJE ASP ............................................................................................................................ 57
2.16.7 LENGUAJE ASP.NET .................................................................................................................... 57
2.16.8 LENGUAJE JSP ............................................................................................................................. 58
2.16.9 LENGUAJE PYTHON .................................................................................................................... 59
2.16.10 LENGUAJE RUBY ....................................................................................................................... 61
2.17 TEGNOLOGIAS UTILIZADAS EN EL SISTEMA ....................................................................................... 62
2.17.1 PHP ............................................................................................................................................. 62
2.17.2 MYSQL ........................................................................................................................................ 65
CAPÍTULO 3 ...................................................................................................................................................... 67
3.1 DESARROLLO DEL SISTEMA DE PROGRAMACION ACADEMICA DE LA FACULTAD DE CONTADURIA
Y ADMINISTRACIÓN ..................................................................................................................... 68
CAPITULO 4 .................................................................................................................................................... 104
INTRODUCCIÓN ........................................................................................................................................ 105
4. 1 CONCLUSIONES Y RESULTADOS ......................................................................................................... 106
4.2 RECOMENDACIONES ........................................................................................................................... 108
4.3 GLOSARIO............................................................................................................................................ 109
4.4 BIBLIOGRAFÍA...................................................................................................................................... 110
4.5 ANEXO ................................................................................................................................................. 111
6
CAPITULO 1
7
1.1 Introducción
La Universidad Veracruzana (U.V) es una Institución pública de educación
superior, la cual es reconocida como la Universidad de mayor impacto en el
sureste de la República Mexicana. Por medio de sus funciones de docencia,
investigación, difusión de la cultura y extensión de servicios en sus distintas
entidades académicas (facultades, institutos de investigación, organismos de
difusión y extensión, entre otros), busca conservar, crear y transmitir la cultura
para beneficiar a la sociedad.
Se rige según las disposiciones de una Ley de Autonomía, una Ley
Orgánica, un Estatuto General y demás Estatutos y Reglamentos derivados
creados en la misma Universidad, donde se trata de vincular de modo permanente
a la Universidad y la educación que ésta imparte con la sociedad, atendiendo a las
nuevas tendencias y condiciones de desarrollo a nivel nacional e internacional.
En la Universidad Veracruzana campus Coatzacoalcos, la Facultad de
Contaduría y Administración(F.C.A) cuenta con un gran número de estudiantes
inscritos en sus aulas fomentando el conocimiento, autonomía, responsabilidad y
dedicación.
Por ello existen procesos y procedimientos de control que dan seguimiento a cada
uno de los estudiantes y su trayectoria académica. Observado esto
se ha
identificado la necesidad de creación de un sistema de control académico que se
adecue a los requerimientos específicos de información en la F.C.A
En el presente trabajo se mencionan las etapas incluidas en el ciclo de desarrollo
de sistemas contemplando las etapas de diseño y programación de sistemas en
un entorno de aplicaciones web.
8
1.2 Planteamiento del problema
La Facultad de Contaduría y Administración (F.C.A) de la Universidad
Veracruzana campus Coatzacoalcos, carece de un sistema capaz de facilitar la
elaboración de la carga académica de los estudiantes al iniciar el periodo escolar,
toda esta labor es llevada acabó por la secretaria académica.
La secretaria académica de la F.C.A es la encargada de evaluar la trayectoria y
carga académica de cada uno de los estudiantes al inicio de cada periodo escolar,
esto lo realiza consultando la información de cada estudiante generada por un
Sistema Integral de Información Universitaria (SIIU) , por medio de este sistema se
pretende lograr que los estudiantes elijan las experiencias educativas que les
corresponden según el periodo al que se van a inscribir, logrando de esta manera
que el estudiante no tenga un atraso académico.
El objetivo principal de esta obra se define en la creación de una aplicación o
sistema informático con las características y requerimientos específicos para
ofrecer una solución a la problemática existente. Esta consiste en identificar los
procedimientos
utilizados en la elaboración de la carga académica de los
estudiantes. Tal proceso se lleva a cabo en un periodo semestral, a través de la
evaluación de ciertos criterios utilizados
para autorizar las experiencias
educativas correspondientes a cada estudiante, además de dar seguimiento a su
trayectoria académica y considerar alternativas que
beneficien su avance
escolar.
El proceso de desarrollo del sistema inicia con la especificación de
los
requerimientos y la definición del entorno, esto a fin de delimitar las funciones,
características y herramientas que se debían diseñar e implementar en siguientes
9
etapas. Esto es realizado bajo la metodología de modelado de lenguaje unificado
el cual permite cumplir con esta tarea adecuadamente, a través del
uso de
esquemas, diagramas y clases que detalladamente describían el sistema.
Posteriormente se abordan estrategias para la definición de una base de datos
integral y flexible, que permitiese administrar la información de una forma sencilla
a través de los scripts de que la aplicación implementase. Cabe mencionar que un
objetivo primordial en la congruencia de los datos y la disponibilidad.
Es importante mantener una congruencia entre la etapa de análisis y la etapa de
desarrollo por lo cual una correcta comunicación será necesaria para llevar a cabo
lo que se ha solicitado y planeado.
1.3 Justificación
Es de
gran importancia y utilidad proveer
a la
administración académica
herramientas que permitan una organizada estructura para llevar a
cabo el
seguimiento académico de cada estudiante de la facultad. Así mismo hacer
más eficiente el control necesario en cada caso particular para analizar y
ofrecer alternativas que beneficien a los estudiantes.
En la Facultad de Contaduría y Administración la secretaria académica es la que
se encarga de ver que experiencias educativas son las que se le otorgan a cada
estudiante, este proceso lo realiza manualmente, verificando en la plataforma del
SIIU el cual es un sistema propio de la Universidad Veracruzana, donde se puede
consultar los datos de los estudiantes, es de ahí donde la secretaria académica
analiza, las experiencias educativas del semestre que comienza y se verifica que
el estudiante este al corriente con su carga académica del periodo en el que se
encuentra cursando.
10
A través de la implementación del sistema propuesto se pretende facilitar la tarea
de programación académica realizada cada periodo escolar.
1.4 Objetivo general
Desarrollar un sistema que permita administrar un control escolar de
estudiantes de la Facultad
los
de Contaduría y Administración para la toma de
decisiones en la asignación de maestros y grupos, bajo el enfoque
de diseño y
programación de sistemas.
1.5 Objetivos específicos
 Analizar
el
sistema bajo el
enfoque
de lenguaje de
modelado
unificado(UML), aplicando las normativas generales del estándar.
 Desarrollar una aplicación flexible y estructurada e integrar elementos que
brinden recursos para facilitar las tareas realizadas por los usuarios.
 Utilizando recursos
informáticos de
fuente
abierta, aprovechando las
características que permitan un máximo rendimiento de los recursos de
los equipos.
 Desarrollar Y
diseñar herramientas
que provean al usuario
de
alternativas útiles para un trabajo eficiente.
1.6 Limitaciones
 El tiempo con el que se cuenta es reducido, por lo cual cada una de las
etapas abordadas en el desarrollo del sistema deberán realizarse en
periodos cortos
11
 El usuario principal desempeña diversas ocupaciones, por lo cual no se
contara con periodos regulares de comunicación.
 El acceso a la base de datos principal es inaccesible, lo cual hace
necesario la implementación de una base de datos específica para el
sistema.
1.7 Delimitaciones
 El sistema a desarrollar está establecido para uso interno de la Facultad
de Contaduría y Administración, por consecuente existe una delimitante
en su implantación.
 Debido al número de usuarios que van a interactuar con el sistema las
especificaciones
y manuales de referencia al sistema no han sido
contemplados.
12
CAPITULO 2
13
Introducción
Un sistema de información (SI) es un conjunto de elementos orientados al
tratamiento y administración de datos e información, organizados y listos para su
posterior uso, generados para cubrir una necesidad (objetivo). (Wikipedia)
Dichos elementos formarán parte de alguna de estas categorías:

Personas.

Datos.

Actividades o técnicas de trabajo.

Recursos materiales en general (típicamente recursos informáticos y de
comunicación, aunque no tienen por qué ser de este tipo obligatoriamente).
Figura 1. Elementos de un sistema de información.
Todos estos elementos interactúan entre sí para procesar los datos (incluyendo
procesos manuales y automáticos) dando lugar a información más elaborada y
distribuyéndola de la manera más adecuada posible en una determinada
organización en función de sus objetivos.
14
Normalmente el término es usado de manera errónea como sinónimo de
sistema de información informático, en parte porque en la mayoría de los casos los
recursos materiales de un sistema de información están constituidos casi en su
totalidad por sistemas informáticos, pero siendo estrictos, un sistema de
información no tiene por qué disponer de dichos recursos. Se podría decir
entonces que los sistemas de información informáticos son una subclase o un
subconjunto de los sistemas de información en general.
2.1 El Ciclo de Vida del Desarrollo de Sistemas
A lo largo de este capítulo de la tesina, se hará referencia al enfoque
sistemático que el analista toma en relación con el análisis y diseño de sistemas
de información. Gran parte de este enfoque se incluye en el ciclo de vida del
desarrollo de sistemas. El cual es un enfoque por fases para el análisis y el diseño
cuya premisa principal consiste en que los sistemas se desarrollan mejor
utilizando un ciclo específico de actividades del analista y el usuario.
Los analistas no se ponen de acuerdo en la cantidad de fases que incluye el
ciclo de vida del desarrollo de sistemas, pero en general alaban su enfoque
organizado. Aquí hemos dividido el ciclo en siete fases. A pesar de que cada fase
se explica por separado, nunca se realiza como un paso aislado. Más bien, es
posible que varias actividades ocurran de manera simultánea, y algunas de ellas
podrían repetirse. Es más práctico considerar que el SDLC se realiza por fases y
no en pasos aislados.
2.2 Identificación de problemas, oportunidades y objetivos
En esta primera fase del ciclo de vida del desarrollo de sistemas, el analista
se ocupa de identificar problemas, oportunidades y objetivos. Esta etapa es crítica
para el éxito del resto del proyecto, pues a nadie le agrada desperdiciar tiempo
trabajando en un problema que no era el que se debía resolver.
15
La primera fase requiere que el analista observe objetivamente lo que
sucede en un negocio.
A continuación, en conjunto con otros miembros de la organización, el
analista determina con precisión cuáles son los problemas. Con frecuencia los
problemas son detectados por alguien más, y ésta es la razón de la llamada inicial
al analista. Las oportunidades son situaciones que el analista considera
susceptibles de mejorar utilizando sistemas de información computarizados. El
aprovechamiento de las oportunidades podría permitir a la empresa obtener una
ventaja competitiva o establecer un estándar para la industria.
La identificación de objetivos también es una parte importante de la primera
fase. En primer lugar, el analista debe averiguar lo que la empresa trata de
conseguir. A continuación, podrá determinar si algunas funciones de las
aplicaciones de los sistemas de información pueden contribuir a que el negocio
alcance sus objetivos aplicándolas a problemas u oportunidades específicos.
Los usuarios, los analistas y los administradores de sistemas que coordinan
el proyecto son los involucrados en la primera fase. Las actividades de esta fase
consisten en entrevistar a los encargados de coordinar a los usuarios, sintetizar el
conocimiento obtenido, estimar el alcance del proyecto y documentar los
resultados. El resultado de esta fase es un informe de viabilidad que incluye una
definición del problema y un resumen de los objetivos.
Figura 2. Elementos de un sistema de información.
16
2.3 Determinación de los requerimientos de información
La siguiente fase que enfrenta el analista es la determinación de los
requerimientos de información de los usuarios. Entre las herramientas que se
utilizan para determinar los requerimientos de información de un negocio se
encuentran métodos interactivos como las entrevistas, los muestreos, la
investigación de datos impresos y la aplicación de cuestionarios; métodos que no
interfieren con el usuario como la observación del comportamiento de los
encargados de tomar las decisiones y sus entornos de oficina, al igual que
métodos de amplio alcance como la elaboración de prototipos.
El desarrollo rápido de aplicaciones es un enfoque orientado a objetos para
el desarrollo de sistemas que incluye un método de desarrollo (que abarca la
generación de requerimientos de información) y herramientas de software.
En la fase de determinación de los requerimientos de información del ciclo
de vida, el analista se esfuerza por comprender la información que necesitan los
usuarios para llevar a cabo sus actividades. Como se puede ver, varios de los
métodos para determinar los requerimientos de información implican interactuar
directamente con los usuarios. Esta fase es útil para que el analista confirme la
idea que tiene de la organización y sus objetivos. En ocasiones sólo realizan las
dos primeras fases del ciclo de vida del desarrollo de sistemas. Esta clase de
estudio podría tener un propósito distinto y por lo general la lleva a la práctica un
especialista conocido como analista de información.
Los implicados en esta fase son el analista y los usuarios, por lo general
trabajadores y gerentes del área de operaciones. El analista de sistemas necesita
conocer los detalles de las funciones del sistema actual: el quién (la gente
involucrada), el qué (la actividad del negocio), el dónde (el entorno donde se
desarrollan las actividades), el cuándo (el momento oportuno) y el cómo (la
manera en que se realizan los procedimientos actuales) del negocio que se
estudia. A continuación el analista debe preguntar la razón por la cual se utiliza el
sistema actual. Podría haber buenas razones para realizar los negocios con los
17
métodos actuales, y es importante tomarlas en cuenta al diseñar un nuevo
sistema.
La reingeniería de procesos de negocios podría ser útil para conceptualizar
el negocio de una manera creativa. Al término de esta fase, el analista debe
conocer el funcionamiento del negocio y poseer información muy completa acerca
de la gente, los objetivos, los datos y los procedimientos implicados.
2.4 Análisis de las necesidades del sistema
La siguiente fase que debe enfrentar el analista tiene que ver con el análisis de las
necesidades del sistema. De nueva cuenta, herramientas y técnicas especiales
auxilian al analista en la determinación de los requerimientos. Una de estas
herramientas es el uso de diagramas de flujo de datos para graficar las entradas,
los procesos y las salidas de las funciones del negocio en una forma gráfica
estructurada. A partir de los diagramas de flujo de datos se desarrolla un
diccionario de datos que enlista todos los datos utilizados en el sistema, así como
sus respectivas especificaciones.
Durante esta fase el analista de sistemas analiza también las decisiones
estructuradas que se hayan tomado. Las decisiones estructuradas son aquellas en
las cuales se pueden determinar las condiciones, las alternativas de condición, las
acciones y las reglas de acción.
Existen
tres
métodos
principales
para
el
análisis
de
decisiones
estructuradas: español estructurado, tablas y árboles de decisión.
En este punto del ciclo de vida del desarrollo de sistemas, el analista
prepara una propuesta de sistemas que sintetiza sus hallazgos, proporciona un
análisis
de
costo/beneficio
de
las
alternativas
y ofrece,
en
su
caso,
recomendaciones sobre lo que se debe hacer. Si la administración de la empresa
considera factible alguna de las recomendaciones, el analista sigue adelante.
Cada problema de sistemas es único, y nunca existe sólo una solución correcta.
18
2.5 Diseño del sistema recomendado
En la fase de diseño del ciclo de vida del desarrollo de sistemas, el analista utiliza
la información recopilada en las primeras fases para realizar el diseño lógico del
sistema de información.
El analista diseña procedimientos precisos para la captura de datos que
aseguran que los datos que ingresen al sistema de información sean correctos.
Además, el analista facilita la entrada eficiente de datos al sistema de información
mediante técnicas adecuadas de diseño de formularios y pantallas.
La concepción de la interfaz de usuario forma parte del diseño lógico del
sistema de información. La interfaz conecta al usuario con el sistema y por tanto
es sumamente importante.
La fase de diseño también incluye el diseño de archivos o bases de datos
que almacenarán gran parte de los datos indispensables para los encargados de
tomar las decisiones en la organización. Una base de datos bien organizada es el
cimiento de cualquier sistema de información.
En esta fase el analista también interactúa con los usuarios para diseñar la
salida (en pantalla o impresa) que satisfaga las necesidades de información de
estos últimos.
Finalmente, el analista debe diseñar controles y procedimientos de respaldo
que protejan al sistema y a los datos, y producir paquetes de especificaciones de
programa para los programadores. Cada paquete debe contener esquemas para
la entrada y la salida, especificaciones de archivos y detalles del procesamiento;
también podría incluir árboles o tablas de decisión, diagramas de flujo de datos, un
diagrama de flujo de sistema, y los nombres y funciones de cualquier rutina de
código previamente escrita.
19
2.6 Desarrollo y documentación del software
En la quinta fase del ciclo de vida del desarrollo de sistemas, el analista trabaja de
manera conjunta con los programadores para desarrollar cualquier software
original necesario. Entre las técnicas estructuradas para diseñar y documentar
software se encuentran los diagramas de estructura, los diagramas de NassiShneiderman y el pseudocódigo. El analista se vale de una o más de estas
herramientas para comunicar al programador lo que se requiere programar.
Durante esta fase el analista también trabaja con los usuarios para
desarrollar documentación efectiva para el software, como manuales de
procedimientos, ayuda en línea y sitios Web que incluyan respuestas a preguntas
frecuentes (FAQ) en archivos "Léame" que se integrarán en el nuevo software. La
documentación indica a los usuarios cómo utilizar el software y lo que deben hacer
en caso de que surjan problemas derivados de este uso.
Los programadores desempeñan un rol clave en esta fase porque diseñan,
codifican y eliminan errores sintácticos de los programas de cómputo. Si el
programa se ejecutará en un entorno de mainframe, se debe crear un lenguaje de
control de trabajos Para garantizar la calidad, un programador podría efectuar un
repaso estructurado del diseño o del código con el propósito de explicar las partes
complejas del programa a otro equipo de programadores.
2.7 Prueba y mantenimiento del sistema
Antes de poner el sistema en funcionamiento es necesario probarlo. Es mucho
menos costoso encontrar los problemas antes que el sistema se entregue a los
usuarios. Una parte de las pruebas las realizan los programadores solos, y otra la
llevan a cabo de manera conjunta con los analistas de sistemas. Primero se
realiza una serie de pruebas con datos de muestra para determinar con precisión
cuáles son los problemas y posteriormente se realiza otra con datos reales del
sistema actual.
20
El mantenimiento del sistema de información y su documentación empiezan
en esta fase y se llevan a cabo de manera rutinaria durante toda su vida útil. Gran
parte del trabajo habitual del programador consiste en el mantenimiento, y las
empresas invierten enormes sumas de dinero en esta actividad. Parte del
mantenimiento, como las actualizaciones de programas, se pueden realizar de
manera automática a través de un sitio Web. Muchos de los procedimientos
sistemáticos que el analista emplea durante el ciclo de vida del desarrollo de
sistemas pueden contribuir a garantizar que el mantenimiento se mantendrá al
mínimo.
2.8 Implementación y evaluación del sistema
Ésta es la última fase del desarrollo de sistemas, y aquí el analista participa en la
implementación del sistema de información. En esta fase se capacita a los
usuarios en el manejo del sistema. Parte de la capacitación la imparten los
fabricantes, pero la supervisión de ésta es responsabilidad del analista de
sistemas. Además, el analista tiene que planear una conversión gradual del
sistema anterior al actual. Este proceso incluye la conversión de archivos de
formatos anteriores a los nuevos, o la construcción de una base de datos, la
instalación de equipo y la puesta en producción del nuevo sistema.
Se menciona la evaluación como la fase final del ciclo de vida del desarrollo
de sistemas principalmente en aras del debate. En realidad, la evaluación se lleva
a cabo durante cada una de las fases. Un criterio clave que se debe cumplir es si
los usuarios a quienes va dirigido el sistema lo están utilizando realmente.
Debe hacerse hincapié en que, con frecuencia, el trabajo de sistemas es
cíclico. Cuando un analista termina una fase del desarrollo de sistemas y pasa a la
siguiente, el surgimiento de un problema podría obligar al analista a regresar a la
fase previa y modificar el trabajo realizado.
21
2.9 Impacto del mantenimiento
Después de instalar un sistema, se le debe dar mantenimiento, es decir, los
programas de cómputo tienen que ser modificados y actualizados cuando lo
requieran.
El mantenimiento se realiza por dos razones. La primera es la corrección de
errores del software. No importa cuán exhaustivamente se pruebe el sistema, los
errores se cuelan en los programas de cómputo. Los errores en el software
comercial para PC se documentan como "anomalías conocidas", y se corrigen en
el lanzamiento de nuevas versiones del software o en revisiones intermedias. En
el software hecho a la medida, los errores se deben corregir en el momento que se
detectan.
La otra razón para el mantenimiento del sistema es la mejora de las
capacidades del software en respuesta a las cambiantes necesidades de una
organización, que por lo general tienen que ver con alguna de las siguientes tres
situaciones:
1. Con frecuencia, después de familiarizarse con el sistema de cómputo y
sus capacidades, los usuarios requieren características adicionales.
2. El negocio cambia con el tiempo.
3. El hardware y el software cambian a un ritmo acelerado.
22
2.10 Programación
2.10.1 Antecedentes
La programación es el proceso de diseñar, escribir, depurar y mantener el código
fuente de programas computacionales. El código fuente es escrito en un lenguaje
de programación. El propósito de la programación es crear programas que
exhiban un comportamiento deseado. El proceso de escribir código requiere
frecuentemente conocimientos en varias áreas distintas, además del dominio del
lenguaje a utilizar, algoritmos especializados y lógica formal. Programar no
involucra necesariamente otras tareas tales como el análisis y diseño de la
aplicación (pero sí el diseño del código), aunque sí suelen estar fusionadas en el
desarrollo de pequeñas aplicaciones.
2.10.2 Historia
Para crear un programa, y que la computadora interprete y ejecute las
instrucciones escritas en él, debe usarse un lenguaje de programación.
En sus inicios las computadoras interpretaban sólo instrucciones en un
lenguaje específico, del más bajo nivel, conocido como código máquina, siendo
éste excesivamente complicado para programar. De hecho sólo consiste en
cadenas de números 1 y 0 (Sistema binario).
Para facilitar el trabajo de programación, los primeros científicos que
trabajaban en el área decidieron reemplazar las instrucciones, secuencias de unos
y ceros, por palabras o letras provenientes del inglés; codificándolas así y creando
un lenguaje de mayor nivel, que se conoce como Assembly o lenguaje
ensamblador. Por ejemplo, para sumar se usa la letra A de la palabra inglesa add
(sumar). En realidad escribir en lenguaje ensamblador es básicamente lo mismo
23
que hacerlo en lenguaje máquina, pero las letras y palabras son bastante más
fáciles de recordar y entender que secuencias de números binarios.
A medida que la complejidad de las tareas que realizaban las computadoras
aumentaba, se hizo necesario disponer de un método sencillo para programar.
Entonces, se crearon los lenguajes de alto nivel. Mientras que una tarea tan trivial
como multiplicar dos números puede necesitar un conjunto de instrucciones en
lenguaje ensamblador, en un lenguaje de alto nivel bastará con solo una.
Una vez que se termina de escribir un programa, sea en ensamblador o en
un lenguaje de alto nivel, es necesario compilarlo, es decir, traducirlo a lenguaje
máquina.
2.10.3 Léxico y programación
La programación se rige por reglas y un conjunto más o menos reducido de
órdenes, expresiones, instrucciones y comandos que tienden a asemejarse a una
lengua natural acotada y que además tienen la particularidad de una reducida
ambigüedad. Cuanto menos impreciso es un lenguaje de programación, se dice,
es más potente. Bajo esta premisa, y en el extremo, el lenguaje más potente
existente es el binario, con ambigüedad nula.
El lenguaje de programación1 es una “notación para comunicarle a una
computadora lo que deseamos que haga”
En los lenguajes de programación de alto nivel se distinguen diversos elementos
entre los que se incluyen el léxico propio del lenguaje y las reglas semánticas y
sintácticas.
1
Louden, K. C. (s.f.). Kenneth C. Louden. Ciencias e Ingenierías.
24
2.10.4 Objetivos de la programación
La programación debe perseguir la obtención de programas de calidad. Para ello
se establece una serie de factores que determinan la calidad de un programa.
Algunos de los factores de calidad más importantes son los siguientes:
Corrección: Un programa es correcto si hace lo que debe hacer tal y como se
estableció en las fases previas a su desarrollo. Para determinar si un programa
hace lo que debe, es muy importante especificar claramente qué debe hacer el
programa antes de desarrollarlo y, una vez acabado, compararlo con lo que
realmente hace.
Claridad: Es muy importante que el programa sea lo más claro y legible posible,
para facilitar así su desarrollo y posterior mantenimiento. Al elaborar un programa
se debe intentar que su estructura sea sencilla y coherente, así como cuidar el
estilo en la edición; de esta forma se ve facilitado el trabajo del programador, tanto
en la fase de creación como en las fases posteriores de corrección de errores,
ampliaciones, modificaciones, etc. Fases que pueden ser realizadas incluso por
otro programador, con lo cual la claridad es aún más necesaria para que otros
programadores puedan continuar el trabajo fácilmente.
Eficiencia: Se trata de que el programa, además de realizar aquello para lo que
fue creado (es decir, que sea correcto), lo haga gestionando de la mejor forma
posible los recursos que utiliza. Normalmente, al hablar de eficiencia de un
programa, se suele hacer referencia al tiempo que tarda en realizar la tarea para la
que ha sido creado y a la cantidad de memoria que necesita, pero hay otros
recursos que también pueden ser de consideración al obtener la eficiencia de un
programa, dependiendo de su naturaleza .
Portabilidad: Un programa es portable cuando tiene la capacidad de poder
ejecutarse en una plataforma, ya sea hardware o software, diferente a aquélla en
la que se elaboró. La portabilidad es una característica muy deseable para un
programa.
25
2.11 Clasificación lenguajes de programación
2.11.1 Primera Generación
Al desarrollarse las primeras computadoras electrónicas, se vio la necesidad de
programarlas, es decir, de almacenar en memoria la información sobre la tarea
que iban a ejecutar. Las primeras se usaban como calculadoras simples; se les
indicaban los pasos de cálculo, uno por uno.
John Von Neumann desarrolló el modelo que lleva su nombre, para
describir este concepto de "programa almacenado". En este modelo, se tiene una
abstracción de la memoria como un conjunto de celdas, que almacenan
simplemente números. Estos números pueden representar dos cosas: los datos,
sobre los que va a trabajar el programa; o bien, el programa en sí.
Se tenía el problema de representar las acciones que iba a realizar la
computadora,
y
que
la
memoria,
al
estar
compuesta
por
switches
correspondientes al concepto de bit, solamente nos permitía almacenar números
binarios.
La descripción y uso de los opcodes es lo que llamamos lenguaje de
máquina. Es decir, la lista de códigos que la máquina va a interpretar como
instrucciones, describe las capacidades de programación que tenemos de ella; es
el lenguaje más primitivo, depende directamente del hardware, y requiere del
programador que conozca el funcionamiento de la máquina al más bajo nivel.
Los lenguajes más primitivos fueron los lenguajes de máquina. Esto, ya que
el hardware se desarrolló antes del software, y además cualquier software
finalmente tiene que expresarse en el lenguaje que maneja el hardware.
26
La programación en esos momentos era sumamente tediosa, pues el programador
tenía que "bajarse" al nivel de la máquina y decirle, paso a pasito, cada punto de
la tarea que tenía que realizar. Además, debía expresarlo en forma numérica; y
por supuesto, este proceso era propenso a errores, con lo que la productividad del
programador era muy limitada. Sin embargo, hay que recordar que en estos
momentos, simplemente aún no existía alternativa.
2.11.2 Segunda Generación
El primer gran avance que se dio, como ya se comentó, fue la abstracción dada
por el Lenguaje Ensamblador, y con él, el nacimiento de las primeras herramientas
automáticas para generar el código máquina. Esto redujo los errores triviales,
como podía ser el número que correspondía a una operación, que son sumamente
engorrosos y difíciles de detectar, pero fáciles de cometer. Sin embargo, aún aquí
es fácil para el programador perderse y cometer errores de lógica, pues debe bajar
al nivel de la forma en que trabaja el CPU, y entender bien todo lo que sucede
dentro de él.
2.11.3 Tercera Generación
Con el desarrollo en los 50s y 60s de algoritmos de más elevado nivel, y el
aumento de poder del hardware, empezaron a entrar al uso de computadoras
científicos de otras ramas; ellos conocían mucho de Física, Química y otras ramas
similares, pero no de Computación, y por supuesto, les era sumamente
complicado trabajar con lenguaje Ensamblador en vez de fórmulas.
27
Así, nació el concepto de Lenguaje de Alto Nivel, con el primer compilador
de FORTRAN que, como su nombre indica, inició como un "simple" esfuerzo de
traducir un lenguaje de fórmulas, al lenguaje ensamblador y por consiguiente al
lenguaje de máquina. A partir de FORTRAN, se han desarrollado innumerables
lenguajes, que siguen el mismo concepto: buscar la mayor abstracción posible, y
facilitar la vida al programador, aumentando la productividad, encargándose los
compiladores o intérpretes de traducir el lenguaje de alto nivel, al lenguaje de
computadora.
Hay que notar la existencia de lenguajes que combinan características de
los de alto nivel y los de bajo nivel (es decir, Ensamblador). Mi ejemplo favorito es
C: contiene estructuras de programación de alto nivel, y la facilidad de usar
librerías que también son características de alto nivel; sin embargo, fue diseñado
con muy pocas instrucciones, las cuales son sumamente sencillas, fáciles de
traducir al lenguaje de la máquina; y requiere de un entendimiento apropiado de
cómo funciona la máquina, el uso de la memoria, etcétera. Por ello, muchas
personas consideramos a lenguajes como C (que fue diseñado para hacer
sistemas operativos), lenguajes de nivel medio.
2.11.4 Cuarta Generación
Los idiomas de la cuarta generación parecen según las instrucciones a las de la
tercera generación. Lo nuevo de estos lenguajes son conceptos como clases,
objetos y eventos que permiten soluciones más fáciles y lógicos. Lenguajes como
C++, java y C# se llaman lenguajes orientadas al objeto.
Los idiomas modernos, tal como C++ y Java, no sólo permite las
abstracciones, pero permite la implementación impuesta de restricciones en
abstracciones.
28
2.11.5 Quinta Generación
Como la quinta generación están conocidos los Lenguajes de inteligencia artificial.
Han sido muy valorados al principio de las noventa - mientras ahora el desarrollo
de software toma otros caminos.
Lo que veremos en el futuro es menos dependencia en el idioma, y más en
el modelado tal como el lenguaje unificado de modelado (UML).
29
2.12 Programas y algoritmos
Un algoritmo es una secuencia no ambigua, finita y ordenada de instrucciones que
han de seguirse para resolver un problema. Un programa normalmente
implementa (traduce a un lenguaje de programación concreto) uno o más
algoritmos. Un algoritmo puede expresarse de distintas maneras: en forma gráfica,
como un diagrama de flujo, en forma de código como en pseudocódigo o un
lenguaje de programación, en forma explicativa, etc.
Los programas suelen subdividirse en partes menores, llamadas módulos,
de modo que la complejidad algorítmica de cada una de las partes sea menor que
la del programa completo, lo cual ayuda al desarrollo del programa.
Un programa está formado por los algoritmos y la estructura de datos. Se han
propuesto diversas técnicas de programación cuyo objetivo es mejorar tanto el
proceso de creación de software como su mantenimiento. Entre ellas, se pueden
mencionar las siguientes:

Programación estructurada

Programación modular

Programación orientada a objetos (POO)

Programación declarativa

Compilación
El programa escrito en un lenguaje de programación (fácilmente comprensible
por el programador) es llamado programa fuente y no se puede ejecutar
directamente en una computadora. La opción más común es compilar el programa
obteniendo un módulo objeto, aunque también puede ejecutarse en forma más
directa a través de un intérprete informático.
El código fuente del programa se debe someter a un proceso de traducción
para convertirlo en lenguaje máquina, código éste directamente ejecutable por el
procesador. A este proceso se le llama compilación.
30
Normalmente la creación de un programa ejecutable (un típico.exe para
Microsoft Windows o DOS) conlleva dos pasos. El primer paso se llama
compilación (propiamente dicho) y traduce el código fuente escrito en un lenguaje
de programación almacenado en un archivo a código en bajo nivel (normalmente
en código objeto, no directamente a lenguaje máquina). El segundo paso se llama
enlazado en el cual se enlaza el código de bajo nivel generado de todos los
ficheros y subprogramas que se han mandado compilar y se añade el código de
las funciones que hay en las bibliotecas del compilador para que el ejecutable
pueda comunicarse directamente con el sistema operativo, traduciendo así
finalmente el código objeto a código máquina, y generando un módulo ejecutable.
Estos dos pasos se pueden hacer por separado, almacenando el resultado
de la fase de compilación en archivos objetos (un típico.obj para Microsoft
Windows, DOS o para Unix); para enlazarlos en fases posteriores, o crear
directamente el ejecutable; con lo que la fase de compilación se almacena sólo
temporalmente. Un programa podría tener partes escritas en varios lenguajes (por
ejemplo C, C++ y ensamblador), que se podrían compilar de forma independiente
y luego enlazar juntas para formar un único módulo ejecutable.
2.12.1 Programación estructurada
La programación estructurada es
una
técnica
para
escribir
programas
(programación de computadora) de manera clara. Para ello se utilizan únicamente
tres estructuras: secuencia, selección e iteración.
Hoy en día las aplicaciones informáticas son mucho más ambiciosas que las
necesidades de programación existentes en los años 1960, principalmente debido
a las aplicaciones gráficas, por lo que las técnicas de programación estructurada
no son suficientes. Ello ha llevado al desarrollo de nuevas técnicas, tales como la
programación orientada a objetos y el desarrollo de entornos de programación que
facilitan la programación de grandes aplicaciones.
31
2.12.2 Orígenes de la programación estructurada
A finales de los años 1960’s surgió una nueva forma de programar que no
solamente daba lugar a programas fiables y eficientes, sino que además estaban
escritos de manera que facilitaba su comprensión posterior.
El teorema del programa estructurado, propuesto por Böhm-Jacopini,
demuestra que todo programa puede escribirse utilizando únicamente las tres
instrucciones de control siguientes:

Secuencia

Instrucción condicional.

Iteración (bucle de instrucciones) con condición al principio.
Solamente con estas tres estructuras se pueden escribir todos los programas y
aplicaciones posibles. Si bien los lenguajes de programación tienen un mayor
repertorio de estructuras de control, éstas pueden ser construidas mediante las
tres básicas citadas.
2.12.3 Estructura secuencial
Una estructura de programa es secuencial si las instrucciones se ejecutan una tras
otra, a modo de secuencia lineal, es decir que una instrucción no se ejecuta hasta
que finaliza la anterior, ni se bifurca el flujo del programa.
32
2.12.4 Estructura selectiva o de selección
La estructura selectiva permite que la ejecución del programa se bifurque a una
instrucción (o conjunto) u otras, según un criterio o condición lógica establecida,
sólo uno de los caminos en la bifurcación será el tomado para ejecutarse.
Ejemplo:
IF a > b THEN
PRINT a ; " es mayor que " ; b
ELSE
PRINT a ; " no es mayor que " ; b
END IF
La instrucción selectiva anterior puede presentar uno de dos mensajes: a es
mayor que b o a no es mayor que b, según el resultado de la comparación entre a
y b; si el resultado de a > b es verdadero, se presenta el primer mensaje, si es
falso se exterioriza el segundo. Las palabras clave IF, THEN, ELSE, y END IF;
constituyen la propia estructura de la instrucción condicional (palabra reservadas),
proporcionada por el lenguaje, el usuario no debe utilizar sus nombres salvo para
este fin. El caso ejemplo se ha codificado en BASIC.
IF señala el comienzo de la instrucción condicional, y se espera que después siga
la condición lógica de control de la instrucción.
33
THEN señala el fin de la condición, y después estará la instrucción a ejecutar si la
condición es verdadera.
ELSE es opcional, le sigue la instrucción que se ejecutará si la condición es falsa.
END IF indica el final de la estructura, luego de ésta el programa seguirá su curso.
Ampliando un poco el ejemplo anterior, con estructuras anidadas:
IF a > b THEN
PRINT a ; " es mayor que " ; b
ELSEIF a < b THEN
PRINT a ; " es menor que " ; b
ELSE
PRINT a ; " es igual que " ; b
END IF
Este ejemplo permite considerar situaciones en las que se tiene más de dos
alternativas. En este caso se ha considerado tres, pero hay situaciones en las que
deben considerarse más casos y para ellos se puede repetir las veces que sea
necesario la opcional ELSEIF.
34
2.12.5 Estructura iterativa
Un bucle iterativo o iteración de una secuencia de instrucciones, hace que se
repita su ejecución mientras se cumpla una condición, el número de iteraciones
normalmente está determinado por el cambio en la condición dentro del mismo
bucle, aunque puede ser forzado o explícito por otra condición.
Ejemplo:
a= 0
b= 7
DO WHILE b > a
PRINT a
a= a + 1
LOOP
Esta instrucción tiene tres palabras reservadas WHILE, DO y LOOP.
DO WHILE: señala el comienzo del bucle ("haga mientras") y después de estas
palabras se espera la condición lógica de repetición, si la condición es verdadera
pasa el control al cuerpo del bucle, en caso contrario el flujo salta directamente al
final de la estructura, saliendo de la misma.
LOOP: señala el final del cuerpo de la estructura de bucle.
El bucle mientras, se repite mientras la condición sea verdadera, esta condición se
comprueba o chequea antes de ingresar al cuerpo del bucle, por lo que el mismo
puede que no se ejecute nunca (cuando la condición es falsa desde un principio) o
bien que se repita tantas veces como resulte y mientras la condición sea cierta.
En el ejemplo se tienen definidas dos variables a y b, que al iniciarse el bucle
contienen los valores a=0 y b=7.
35
La condición del bucle es b > a.
Si a=0 y b=7. la condición es verdadera, en el cuerpo del bucle se escribe el valor
de a en pantalla y luego se incrementa esa variable en una unidad. Entonces pasa
a ser a=1 y b=7.
... (se repite la secuencia)
...
Cuando a=6 y b=7. la condición sigue siendo verdadera, se escribe el valor de a
en pantalla y se incrementa en una unidad.
Cuando se llega a que a=7 y b=7. Entonces la condición ya resulta falsa y la
instrucción WHILE finaliza, saliendo por LOOP.
La salida por pantalla de este ejemplo es 0 1 2 3 4 5 6, y se iteró 7 veces.
El lenguaje utilizado en el ejemplo (BASIC), además de tener otras del tipo
iterativas, permite utilizar la misma estructura indicada, pero de la siguiente forma:
a= 0
b= 7
WHILE b > a
PRINT a
a= a + 1
WEND
Que es absolutamente análoga, en éste formato la palabra reservada WEND
marca el fin del bucle y no se utiliza ni DO ni LOOP.
36
2.12.6 Ventajas de la programación estructurada
1. Los programas son más fáciles de entender, pueden ser leídos de forma
secuencial, no hay necesidad de hacer engorrosos seguimientos en saltos de
línea (GOTO) dentro de los bloques de código para intentar entender la lógica.
2. La estructura de los programas es clara, puesto que las instrucciones están más
ligadas o relacionadas entre sí.
3. Reducción del esfuerzo en las pruebas y depuración. El seguimiento de los
fallos o errores del programa se facilita debido a su estructura más sencilla y
comprensible, por lo que los errores se pueden detectar y corregir más fácilmente.
4. Reducción de los costos de mantenimiento. Análogamente a la depuración,
durante la fase de mantenimiento, modificar o extender los programas resulta más
fácil.
5. Programas son más sencillos y más rápidos de confeccionar (y se facilita su
optimización).
6. Los bloques de código son casi auto-explicativos, lo que reduce y facilita la
documentación.
7. Las instrucciones de salto, GOTO, quedan reservadas para construir las
instrucciones básicas, si fuera realmente imprescindible. Aunque no se usan de
forma directa, por estar prohibida su utilización, están incluidas implícitamente en
las instrucciones de selección e iteración.
8. Un programa escrito de acuerdo a los principios de programación estructurada
no solamente tendrá una mejor estructura sino también una excelente
presentación.
9. Se incrementa el rendimiento de los programadores, comparada con la forma
tradicional que utiliza GOTO.
37
La programación estructurada ofrece estos beneficios, pero no se la debe
considerar como una panacea ya que el desarrollo de programas es,
esencialmente, una tarea de dedicación, esfuerzo y creatividad; programar es casi
un arte.
2.12.7 Inconvenientes de la programación estructurada
El principal inconveniente de este método de programación es que se obtiene un
único bloque de programa, que cuando se hace demasiado grande puede resultar
problemático el manejo de su código fuente; esto se resuelve empleando
conjuntamente la programación modular, es decir, si es necesario, se definen
módulos independientemente, programados y compilados por separado (en
realidad esto no es necesario, pero si es recomendable para su mejor
mantenimiento y depuración).
En realidad, cuando se programa hoy en día (inicios del siglo XXI) se
utilizan normalmente, tanto las técnicas de programación estructurada como las de
programación modular, de forma conjunta y por lo tanto es muy común que
cuando se hace referencia a la programación estructurada muchos entiendan que
ella incluye también las técnicas modulares, estrictamente no es así.
Un método un poco más sofisticado es la programación por capas, en la
que los módulos tienen una estructura jerárquica en la que se pueden definir
funciones dentro de funciones o de procedimientos.
Si bien las metodologías en cuestión ya son de antigua data, aun en la
actualidad la conjunción "Programación estructurada" y "programación modular"
es una de la más utilizadas, juntamente con un más moderno paradigma, en pleno
auge, completamente distinto, llamado programación orientada a objetos.
38
2.13 Programación modular
La programación modular es un paradigma de programación que consiste en
dividir un programa en módulos o subprogramas con el fin de hacerlo más legible
y manejable.
Se presenta históricamente como una evolución de la programación
estructurada para solucionar problemas de programación más grandes y
complejos de lo que ésta puede resolver.
Al aplicar la programación modular, un problema complejo debe ser dividido
en varios sub-problemas más simples, y estos a su vez en otros sub-problemas
más simples. Esto debe hacerse hasta obtener sub-problemas lo suficientemente
simples como para poder ser resueltos fácilmente con algún lenguaje de
programación. Ésta técnica se llama refinamiento sucesivo, divide y vencerás ó
análisis descendente (Top-Down).
Un módulo es cada una de las partes de un programa que resuelve uno de
los sub-problemas en que se divide el problema complejo original. Cada uno de
estos módulos tiene una tarea bien definida y algunos necesitan de otros para
poder operar. En caso de que un módulo necesite de otro, puede comunicarse con
éste mediante una interfaz de comunicación que también debe estar bien definida.
Si bien un módulo puede entenderse como una parte de un programa en
cualquiera de sus formas y variados contextos, en la práctica se los suele tomar
como sinónimos de procedimientos y funciones. Pero no necesaria ni
estrictamente un módulo es una función o un procedimiento, ya que el mismo
puede contener muchos de ellos, no debe confundirse el término "modulo" (en el
sentido de programación modular) con términos como "función" o "procedimiento",
propios del lenguaje que lo soporte
39
2.14 Paradigma por eventos
En contraposición al modelo clásico, la programación orientada a eventos permite
interactuar con el usuario en cualquier momento de la ejecución. Esto se consigue
debido a que los programas creados bajo esta arquitectura se componen por un
bucle exterior permanente encargado de recoger los eventos, y distintos procesos
que se encargan de tratarlos. Habitualmente, este bucle externo permanece oculto
al programador que simplemente se encarga de tratar los eventos, aunque en
algunos lenguajes será necesaria su construcción. Ejemplo de programa orientado
a eventos en pseudo lenguaje:
While (true){
Switch (event){
case mousse_button_down:
case mouse_click:
case keypressed:
case Else:
}
}
Usos del paradigma dirigido por eventos
Una vez descritos algunos de los patrones que conforman la estructura del
paradigma dirigido por eventos, a continuación se explican algunos ejemplos de
tipos de aplicaciones que en la actualidad hacen uso de este paradigma.
2.14.1Sistemas GUI
En la actualidad la mayoría de las personas que utiliza un computador, hacen uso
de
sistemas que cuentan con interfaces gráficas de usuario (Graphic User
Interface o GUI). La estructura de este tipo de sistemas implementa el patrón
Handler. Cada elemento de una interfaz gráfica como lo son botones, cajas de
40
selección, cajas de edición entre otros, pueden estar en modo de espera hasta la
llegada de un evento como lo es el oprimir algún botón del Mouse sobre uno de
los elementos de la GUI, una vez arribado el evento éstos realizan alguna acción.
Los módulos que componen a este tipo de sistemas son los siguientes: un
elemento que representa los eventos generados externamente por el usuario, un
despachador responsable de analizar los eventos que llegan a éste y una serie de
manejadores que efectúan alguna operación dependiendo del tipo de evento
generado por el usuario.
2.14.2 Sistemas Cliente-Servidor
Un tipo de sistema que utiliza el patrón Handler son los llamados sistemas cliente
servidor. Este tipo de sistemas está compuesto por dos componentes principales
uno o más servidores y uno o más clientes. El servidor puede ser un hardware o
componente software cuya función es proporcionar un determinado tipo de
servicio a los clientes quienes consumen el servicio. El trabajo de los servidores es
esperar por las peticiones de los clientes, responder a las solicitudes de los
clientes proporcionando el servicio y finalmente esperar por más peticiones. A
continuación se muestra el patrón Handler en este tipo de sistemas.
2.14.3 Sistemas de mensajes
Otro tipo de variante del patrón Handler son los sistemas de mensajes. En este
tipo de sistemas existen dos componentes, un generador de eventos llamado
transmisor y un manejador de eventos llamado receptor. Por lo general los
transmisores y receptores se encuentran en distintas ubicaciones físicas o en
distintas plataformas. Este tipo de sistemas utiliza un modelo de conexión punto a
punto ya que los transmisores conocen a que receptor enviar el mensaje.
41
Un ejemplo de este son los sistemas de correo electrónico, un usuario envía un
correo al servidor de correos (sistema de mensajes) el servidor obtiene la
dirección del destinatario y lo envía al receptor.
2.14.4 Características del paradigma orientado a evento
De una manera general se hace mención a las características de este lenguaje al
referir que en el paradigma orientado a evento se pueden determinar acciones
dependientes del usuario debido a que el usuario es que da la acción o el evento
para la ejecución del programa; además de poder manipular los eventos que les
sea concerniente, eventos asociados a métodos y atributos, los cuales son los
procedimientos y características a ejecutar en aplicaciones con diferentes
acciones, de esta manera en el paradigma orientado a evento se emplean
elementos visuales de manera tal de crear un ambiente agradable de trabajo y
una interactividad con el programa permitiendo tener contacto con el empleo de
los objetivos e los eventos predefinidos; en este paradigma es el usuario quien
decide.
42
2.15 Programación orientada a objetos
La programación orientada a objetos o POO (OOP según sus siglas en inglés) es
un paradigma de programación que usa objetos y sus interacciones, para diseñar
aplicaciones y programas informáticos. Está basado en varias técnicas, incluyendo
herencia, abstracción, polimorfismo y encapsulamiento. Su uso se popularizó a
principios de la década de los años 1990’s. En la actualidad, existe variedad de
lenguajes de programación que soportan la orientación a objetos.Los objetos son
entidades que tienen un determinado estado, comportamiento (método) e
identidad:
El estado está compuesto de datos, será uno o varios atributos a los que se
habrán asignado unos valores concretos (datos).
El comportamiento está definido por los métodos o mensajes a los que sabe
responder dicho objeto, es decir, qué operaciones se pueden realizar con él.
La identidad es una propiedad de un objeto que lo diferencia del resto,
dicho con otras palabras, es su identificador (concepto análogo al de identificador
de una variable o una constante).
Un objeto contiene toda la información que permite definirlo e identificarlo
frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de
una misma clase, al poder tener valores bien diferenciados en sus atributos. A su
vez, los objetos disponen de mecanismos de interacción llamados métodos, que
favorecen la comunicación entre ellos. Esta comunicación favorece a su vez el
cambio de estado en los propios objetos. Esta característica lleva a tratarlos como
unidades indivisibles, en las que no se separa el estado y el comportamiento.
Los métodos (comportamiento) y atributos (estado) están estrechamente
relacionados por la propiedad de conjunto. Esta propiedad destaca que una clase
requiere de métodos para poder tratar los atributos con los que cuenta. El
43
programador debe pensar indistintamente en ambos conceptos, sin separar ni
darle mayor importancia a alguno de ellos. Hacerlo podría producir el hábito
erróneo de crear clases contenedoras de información por un lado y clases con
métodos que manejen a las primeras por el otro. De esta manera se estaría
realizando una programación estructurada camuflada en un lenguaje de
programación orientado a objetos.
Paradigma orientado a objetos
La POO difiere de la programación estructurada tradicional, en la que los datos y
los procedimientos están separados y sin relación, ya que lo único que se busca
es el procesamiento de unos datos de entrada para obtener otros de salida. La
programación estructurada anima al programador a pensar sobre todo en términos
de procedimientos o funciones, y en segundo lugar en las estructuras de datos
que esos procedimientos manejan. En la programación estructurada sólo se
escriben funciones que procesan datos. Los programadores que emplean POO,
en cambio, primero definen objetos para luego enviarles mensajes solicitándoles
que realicen sus métodos por sí mismos.
2.15.1 Antecedentes
Los conceptos de la programación orientada a objetos tienen origen en Simula 67,
un lenguaje diseñado para hacer simulaciones, creado por Ole-Johan Dahl y
Kristen Nygaard del Centro de Cómputo Noruego en Oslo. En este centro, se
trabajaba en simulaciones de naves, que fueron confundidas por la explosión
combinatoria de cómo las diversas cualidades de diferentes naves podían afectar
unas a las otras. La idea surgió al agrupar los diversos tipos de naves en diversas
clases de objetos, siendo responsable cada clase de objetos de definir sus propios
datos y comportamientos. Fueron refinados más tarde en Smalltalk, desarrollado
en Simula en Xerox PARC (cuya primera versión fue escrita sobre Basic) pero
diseñado para ser un sistema completamente dinámico en el cual los objetos se
podrían crear y modificar "sobre la marcha" (en tiempo de ejecución) en lugar de
tener un sistema basado en programas estáticos.
44
La programación orientada a objetos se fue convirtiendo en el estilo de
programación dominante a mediados de los años ochenta, en gran parte debido a
la influencia de C++, una extensión del lenguaje de programación C. Su
dominación fue consolidada gracias al auge de las Interfaces gráficas de usuario,
para las cuales la programación orientada a objetos está particularmente bien
adaptada. En este caso, se habla también de programación dirigida por eventos.
Las características de orientación a objetos fueron agregadas a muchos
lenguajes existentes durante ese tiempo, incluyendo Ada, BASIC, Lisp, Pascal,
entre otros. La adición de estas características a los lenguajes que no fueron
diseñados inicialmente para ellas condujo a menudo a problemas de
compatibilidad y en la capacidad de mantenimiento del código. Los lenguajes
orientados a objetos "puros", por su parte, carecían de las características de las
cuales muchos programadores habían venido a depender. Para saltar este
obstáculo, se hicieron muchas tentativas para crear nuevos lenguajes basados en
métodos orientados a
objetos,
pero
permitiendo
algunas características
imperativas de maneras "seguras". El Eiffel de Bertrand Meyer fue un temprano y
moderadamente acertado lenguaje con esos objetivos pero ahora ha sido
esencialmente reemplazado por Java, en gran parte debido a la aparición de
Internet, y a la implementación de la máquina virtual de Java en la mayoría de
navegadores. PHP en su versión 5 se ha modificado, soporta una orientación
completa a objetos, cumpliendo todas las características propias de la orientación
a objetos.
2.15.2 Conceptos fundamentales
La programación orientada a objetos es una forma de programar que trata de
encontrar una solución a estos problemas. Introduce nuevos conceptos, que
superan y amplían conceptos antiguos ya conocidos. Entre ellos destacan los
siguientes:
45
Clase: definiciones de las propiedades y comportamiento de un tipo de objeto
concreto. La instanciación es la lectura de estas definiciones y la creación de un
objeto a partir de ellas.
Herencia: (por ejemplo, herencia de la clase C a la clase D) Es la facilidad
mediante la cual la clase D hereda en ella cada uno de los atributos y operaciones
de C, como si esos atributos y operaciones hubiesen sido definidos por la misma
D. Por lo tanto, puede usar los mismos métodos y variables publicas declaradas
en C. Los componentes registrados como "privados" (private) también se heredan,
pero como no pertenecen a la clase, se mantienen escondidos al programador y
sólo pueden ser accedidos a través de otros métodos públicos. Esto es así para
mantener hegemónico el ideal de OOP.
Objeto: entidad provista de un conjunto de propiedades o atributos (datos) y de
comportamiento o funcionalidad (métodos) los mismos que consecuentemente
reaccionan a eventos. Se corresponde con los objetos reales del mundo que nos
rodea, o a objetos internos del sistema (del programa). Es una instancia a una
clase.
Método: Algoritmo asociado a un objeto (o a una clase de objetos), cuya
ejecución se desencadena tras la recepción de un "mensaje". Desde el punto de
vista del comportamiento, es lo que el objeto puede hacer. Un método puede
producir un cambio en las propiedades del objeto, o la generación de un "evento"
con un nuevo mensaje para otro objeto del sistema.
Evento: Es un suceso en el sistema (tal como una interacción del usuario con la
máquina, o un mensaje enviado por un objeto). El sistema maneja el evento
enviando el mensaje adecuado al objeto pertinente. También se puede definir
como evento, a la reacción que puede desencadenar un objeto, es decir la acción
que genera.
Mensaje: una comunicación dirigida a un objeto, que le ordena que ejecute uno de
sus métodos con ciertos parámetros asociados al evento que lo generó.
46
Propiedad o atributo: contenedor de un tipo de datos asociados a un objeto (o a
una clase de objetos), que hace los datos visibles desde fuera del objeto y esto se
define como sus características predeterminadas, y cuyo valor puede ser alterado
por la ejecución de algún método.
Estado interno: es una variable que se declara privada, que puede ser
únicamente accedida y alterada por un método del objeto, y que se utiliza para
indicar distintas situaciones posibles para el objeto (o clase de objetos). No es
visible al programador que maneja una instancia de la clase.
Componentes de un objeto: atributos, identidad, relaciones y métodos.
Identificación de un objeto: un objeto se representa por medio de una tabla o
entidad que esté compuesta por sus atributos y funciones correspondientes.
En comparación con un lenguaje imperativo, una "variable", no es más que un
contenedor interno del atributo del objeto o de un estado interno, así como la
"función" es un procedimiento interno del método del objeto.
2.15.3 Características de la POO
Existe un acuerdo acerca de qué características contempla la "orientación a
objetos", las características siguientes son las más importantes:
Abstracción: denota las características esenciales de un objeto, donde se
capturan sus comportamientos. Cada objeto en el sistema sirve como modelo de
un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y
"comunicarse" con otros objetos en el sistema sin revelar cómo se implementan
estas características. Los procesos, las funciones o los métodos pueden también
ser abstraídos y cuando lo están, una variedad de técnicas son requeridas para
ampliar una abstracción. El proceso de abstracción permite seleccionar las
características relevantes dentro de un conjunto e identificar comportamientos
comunes para definir nuevos tipos de entidades en el mundo real. La abstracción
47
es clave en el proceso de análisis y diseño orientado a objetos, ya que mediante
ella podemos llegar a armar un conjunto de clases que permitan modelar la
realidad o el problema que se quiere atacar.
Encapsulamiento:
Significa
reunir a todos los elementos que
pueden
considerarse pertenecientes a una misma entidad, al mismo nivel de abstracción.
Esto permite aumentar la cohesión de los componentes del sistema. Algunos
autores confunden este concepto con el principio de ocultación, principalmente
porque se suelen emplear conjuntamente.
Modularidad: Se denomina Modularidad a la propiedad que permite subdividir
una aplicación en partes más pequeñas (llamadas módulos), cada una de las
cuales debe ser tan independiente como sea posible de la aplicación en sí y de las
restantes partes. Estos módulos se pueden compilar por separado, pero tienen
conexiones con otros módulos. Al igual que la encapsulación, los lenguajes
soportan la Modularidad de diversas formas.
Principio de ocultación: Cada objeto está aislado del exterior, es un módulo
natural, y cada tipo de objeto expone una interfaz a otros objetos que especifica
cómo pueden interactuar con los objetos de la clase. El aislamiento protege a las
propiedades de un objeto contra su modificación por quien no tenga derecho a
acceder a ellas, solamente los propios métodos internos del objeto pueden
acceder a su estado. Esto asegura que otros objetos no pueden cambiar el estado
interno de un objeto de maneras inesperadas, eliminando efectos secundarios e
interacciones inesperadas. Algunos lenguajes relajan esto, permitiendo un acceso
directo a los datos internos del objeto de una manera controlada y limitando el
grado de abstracción. La aplicación entera se reduce a un agregado o
rompecabezas de objetos.
Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden
compartir el mismo nombre, al llamarlos por ese nombre se utilizará el
comportamiento correspondiente al objeto que se esté usando. O dicho de otro
modo, las referencias y las colecciones de objetos pueden contener objetos de
48
diferentes tipos, y la invocación de un comportamiento en una referencia producirá
el comportamiento correcto para el tipo real del objeto referenciado. Cuando esto
ocurre en "tiempo de ejecución", esta última característica se llama asignación
tardía o asignación dinámica. Algunos lenguajes proporcionan medios más
estáticos (en "tiempo de compilación") de polimorfismo, tales como las plantillas y
la sobrecarga de operadores de C++.
Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando
una jerarquía de clasificación. Los objetos heredan las propiedades y el
comportamiento de todas las clases a las que pertenecen. La herencia organiza y
facilita el polimorfismo y el encapsulamiento permitiendo a los objetos ser
definidos y creados como tipos especializados de objetos preexistentes. Estos
pueden compartir (y extender) su comportamiento sin tener que volver a
implementarlo. Esto suele hacerse habitualmente agrupando los objetos en clases
y estas en árboles o enrejados que reflejan un comportamiento común. Cuando un
objeto hereda de más de una clase se dice que hay herencia múltiple.
Recolección de basura: la recolección de basura es la técnica por la cual el
entorno de objetos se encarga de destruir automáticamente, y por tanto
desvincular la memoria asociada, los objetos que hayan quedado sin ninguna
referencia a ellos. Esto significa que el programador no debe preocuparse por la
asignación o liberación de memoria, ya que el entorno la asignará al crear un
nuevo objeto y la liberará cuando nadie lo esté usando. En la mayoría de los
lenguajes híbridos que se extendieron para soportar el Paradigma de
Programación Orientada a Objetos como C++ u Object Pascal, esta característica
no existe y la memoria debe desasignarse manualmente.
49
2.16 PROGRAMACION DE APLICACIONES WEB
2.16.1 Definición
Desarrollo web es un título para el conjunto de tecnologías de software del lado
del servidor y del cliente que involucran una combinación de procesos de base de
datos con el uso de un navegador en Internet a fin de realizar determinadas tareas
o mostrar información.
Tradicionalmente un software departamental o incluso un ambicioso proyecto
corporativo de gran envergadura es desarrollado en forma standalone, es decir,
usando lenguajes ya sea compilados (C, C++, Delphi) semicompilados (Java), o
interpretados (Python) para crear tanto la funcionalidad como toda la interfaz de
los usuarios, pero cabe perfectamente un desarrollo orientado a web para dichos
propósitos, siendo más homogéneo y multiplataforma, y dependiendo de las
tecnologías utilizadas, más rápido y robusto tanto para diseñar, implementar y
probar, como para su uso una vez terminado.
Funcionalmente, el desarrollador web, que es quien realiza esta labor,
normalmente sólo se preocupa por el funcionamiento del software, es tarea
del diseñador web preocuparse del aspecto finalde la página y del webmaster el
integrar ambas partes.
Los lenguajes de programación más usados en desarrollo web son principalmente:
ASP.NET, PHP y JSP.
50
La base de datos más popular en desarrollo web es MySQL, seguida
por Oracle, SQL Server y PostgreSQL.
Idealmente un desarrollador web debería conocer, además de al menos
un lenguaje de programación y el manejo de al menos una base de
datos, HTML, CSS y JavaScript,
tres
tecnologías
que
bien
trabajadas
logran DHTML. También, si el diseñador desea usar Adobe Flex (Flash) debe ser
capaz de integrarlo a su solución, o puede dejar los efectos en el mismo DHTML.
51
2.16.2 Generalidades de la programación web
Actualmente existen diferentes lenguajes de programación para desarrollar en la
web, estos han ido surgiendo debido a las tendencias y necesidades de las
plataformas. En el presente artículo pretende mostrar las ventajas y desventajas
de los lenguajes más conocidos.
Desde los inicios de Internet, fueron surgiendo diferentes demandas por los
usuarios y se dieron soluciones mediante lenguajes estáticos. A medida que paso
el tiempo, las tecnologías fueron desarrollándose y surgieron nuevos problemas a
dar solución. Esto dio lugar a desarrollar lenguajes de programación para las web
dinámicas. A continuación daremos una introducción a los diferentes lenguajes de
programación para la web.
2.16.3 Lenguaje HTML
HTML2, siglas de HyperText Markup Language («lenguaje de marcado de
hipertexto»), es el lenguaje de marcado predominante para la elaboración de
páginas web. Es usado para describir la estructura y el contenido en forma de
texto, así como para complementar el texto con objetos tales como imágenes.
HTML
se
escribe
en
forma
de
«etiquetas»,
rodeadas
por corchetes
angulares (<,>). HTML también puede describir, hasta un cierto punto, la
apariencia de un documento, y puede incluir un script (por ejemplo JavaScript), el
cual puede afectar el comportamiento de navegadores web y otros procesadores
de HTML.
HTML también es usado para referirse al contenido del tipo de
MIME text/html o todavía más ampliamente como un término genérico para el
HTML, ya sea en forma descendida del XML (como XHTML1.0 y posteriores) o en
forma descendida directamente de SGML (como HTML 4.01 y anteriores).
2
LANCKER, L. V. (s.f.). HTML 4: dominar el código fuente. Eni.
52
Sintaxis:
<html>
<head>
( Cabecera )
</head>
<body>
( Cuerpo )
</body>
</html>
Ventajas:

Sencillo que permite describir hipertexto.

Texto presentado de forma estructurada y agradable.

No necesita de grandes conocimientos cuando se cuenta con un editor de
páginas web o WYSIWYG.

Archivos pequeños.

Despliegue rápido.

Lenguaje de fácil aprendizaje.

Lo admiten todos los exploradores.
Desventajas:

Lenguaje estático.

La interpretación de cada navegador puede ser diferente.

El diseño es más lento.

Las etiquetas son muy limitadas.
53
2.16.4 Lenguaje Javascript
Este es un lenguaje interpretado, no requiere compilación. Fue creado por
Brendan Eich en la empresa Netscape Communications. Utilizado principalmente
en páginas web. Es similar a Java, aunque no es un lenguaje orientado a objetos,
el mismo no dispone de herencias. La mayoría de los navegadores en sus últimas
versiones interpretan código Javascript.
El código Javascript puede ser integrado dentro de nuestras páginas web. Para
evitar incompatibilidades el World Wide Web Consortium (W3C) diseño un
estándar denominadoDOM (en inglés Document Object Model, en su traducción al
español Modelo de Objetos del Documento).
Ventajas:

Lenguaje de scripting seguro y fiable.

Los script tienen capacidades limitadas, por razones de seguridad.

El código Javascript se ejecuta en el cliente.
Desventajas:

Código visible por cualquier usuario.

El código debe descargarse completamente.

Puede poner en riesgo la seguridad del sitio, con el actual problema llamado
XSS (significa en inglés Cross Site Scripting renombrado a XSS por su
similitud con las hojas de estilo CSS).
2.16.5 Lenguaje PHP
54
Es un lenguaje de programación utilizado para la creación de sitio web. PHP3 es
un acrónimo recursivo que significa “PHP Hypertext Pre-processor”, (inicialmente
se llamó Personal Home Page). Surgió en 1995, desarrollado por PHP Group.
PHP es un lenguaje de script interpretado en el lado del servidor utilizado para la
generación de páginas web dinámicas, embebidas en páginas HTML y ejecutadas
en el servidor. PHP no necesita ser compilado para ejecutarse. Para su
funcionamiento necesita tener instalado Apache o IIS con las librerías de PHP. La
mayor parte de su sintaxis ha sido tomada de C, Java y Perl con algunas
características específicas. Los archivos cuentan con la extensión (php).
Sintaxis:
<?
$mensaje = “Hola”;
echo $mensaje;
?>
También puede usarse:
<?php
$mensaje = “Hola”;
echo $mensaje;
?>
Ventajas:

Muy fácil de aprender.

Se caracteriza por ser un lenguaje muy rápido.

Soporta en cierta medida la orientación a objeto. Clases y herencia.

Es un lenguaje multiplataforma: Linux, Windows, entre otros.

Capacidad de conexión con la mayoría de los manejadores de base de datos:
MysSQL, PostgreSQL, Oracle, MS SQL Server, entre otras.
3
Ángel Cobo, P. G. (s.f.). PHP y MySQL. Tecnología para el desarrollo de aplicaciones web. Díaz de Santos.
55

Capacidad de expandir su potencial utilizando módulos.

Posee documentación en su página oficial la cual incluye descripción y
ejemplos de cada una de sus funciones.

Es libre, por lo que se presenta como una alternativa de fácil acceso para
todos.

Incluye gran cantidad de funciones.

No requiere definición de tipos de variables ni manejo detallado del bajo nivel.
Desventajas:

Se necesita instalar un servidor web.

Todo el trabajo lo realiza el servidor y no delega al cliente. Por tanto puede ser
más ineficiente a medida que las solicitudes aumenten de número.

La legibilidad del código puede verse afectada al mezclar sentencias HTML y
PHP.

La programación orientada a objetos es aún muy deficiente para aplicaciones
grandes.

Dificulta la modularidad.

Dificulta la organización por capas de la aplicación.
Seguridad:
PHP es un poderoso lenguaje e intérprete, ya sea incluido como parte de un
servidor web en forma de módulo o ejecutado como un binario CGI separado, es
capaz de acceder a archivos, ejecutar comandos y abrir conexiones de red en el
servidor. Estas propiedades hacen que cualquier cosa que sea ejecutada en un
servidor web sea insegura por naturaleza.
PHP está diseñado específicamente para ser un lenguaje más seguro para escribir
programas CGI que Perl o C, y con la selección correcta de opciones de
configuración en tiempos de compilación y ejecución, y siguiendo algunas
prácticas correctas de programación.
56
2.16.6 Lenguaje ASP
Es una tecnología del lado de servidor desarrollada por Microsoft para el
desarrollo de sitio web dinámicos. ASP significa en inglés (Active Server Pages),
fue liberado por Microsoft en 1996. Las páginas web desarrolladas bajo este
lenguaje es necesario tener instalado Internet Information Server (IIS).
ASP no necesita ser compilado para ejecutarse. Existen varios lenguajes que se
pueden utilizar para crear páginas ASP. El más utilizado es VBScript, nativo de
Microsoft. ASP se puede hacer también en Perl and Jscript. El código ASP puede
ser insertado junto con el código HTML. Los archivos cuentan con la
extensión (asp).
Ventajas:

Usa Visual Basic Script, siendo fácil para los usuarios.

Comunicación óptima con SQL Server.

Soporta el lenguaje JScript.

Desventajas:

Código desorganizado.

Se necesita escribir mucho código para realizar funciones sencillas.

Tecnología propietaria.

Hospedaje de sitios web costosos.
2.16.7 Lenguaje ASP.NET
Este es un lenguaje comercializado por Microsoft, y usado por programadores
para desarrollar entre otras funciones, sitios web. ASP.NET es el sucesor de la
tecnología ASP, fue lanzada al mercado mediante una estrategia de mercado
denominada .NET.
El ASP.NET fue desarrollado para resolver las limitantes que brindaba tu
antecesor ASP. Creado para desarrollar web sencillas o grandes aplicaciones.
Para el desarrollo de ASP.NET se puede utilizar C#, VB.NET o J#. Los archivos
57
cuentan con la extensión (aspx). Para su funcionamiento de las páginas se
necesita tener instalado IIS con el Framework .Net. Microsft Windows 2003 incluye
este framework, solo se necesitará instalarlo en versiones anteriores.
Ventajas:

Completamente orientado a objetos.

Controles de usuario y personalizados.

División entre la capa de aplicación o diseño y el código.

Facilita el mantenimiento de grandes aplicaciones.

Incremento de velocidad de respuesta del servidor.

Mayor velocidad.

Mayor seguridad.
Desventajas:

Mayor consumo de recursos.
2.16.8 Lenguaje JSP
Es un lenguaje para la creación de sitios web dinámicos, acrónimo de Java Server
Pages. Está orientado a desarrollar páginas web en Java. JSP es un lenguaje
multiplataforma. Creado para ejecutarse del lado del servidor.
JSP fue desarrollado por Sun Microsystems. Comparte ventajas similares a las de
ASP.NET, desarrollado para la creación de aplicaciones web potentes. Posee un
motor de páginas basado en los servlets de Java. Para su funcionamiento se
necesita tener instalado un servidor Tomcat.
Sintaxis:
<%= new java.util.Date() %>
Características:

Código separado de la lógica del programa.
58

Las páginas son compiladas en la primera petición.

Permite separar la parte dinámica de la estática en las páginas web.

Los archivos se encuentran con la extensión (jsp).

El código JSP puede ser incrustado en código HTML.
Elementos de JSP
Los elementos que pueden ser insertados en las páginas JSP son los siguientes:

Código: se puede incrustar código “Java”.

Directivas: permite controlar parámetros del códigos.

Acciones: permite alterar el flujo normal de ejecución de una página.
Ventajas:

Ejecución rápida del servlets.

Crear páginas del lado del servidor.

Multiplataforma.

Código bien estructurado.

Integridad con los módulos de Java.

La parte dinámica está escrita en Java.

Permite la utilización se servlets.
Desventajas:

Complejidad de aprendizaje.
2.16.9 Lenguaje Python
Es un lenguaje de programación creado en el año 1990 por Guido van Rossum, es
el
sucesor
del
lenguaje
de
programación
ABC. Python es
comparado
habitualmente con Perl. Los usuarios lo consideran como un lenguaje más limpio
para programar. Permite la creación de todo tipo de programas incluyendo los
sitios web.
59
Su código no necesita ser compilado, por lo que se llama que el código es
interpretado. Es un lenguaje de programación multi-paradigma, lo cual fuerza a
que los programadores adopten por un estilo de programación particular:

Programación orientada a objetos.

Programación estructurada.

Programación funcional.

Programación orientada a aspectos.
Sintaxis:
Ejemplo de una clase en Phyton:
def dibujar_muneco(opcion):
if opcion == 1:
C.create_line(580, 150, 580, 320, width=4, fill="blue")
C.create_oval(510, 150, 560, 200, width=2, fill='PeachPuff')
Ventajas:

Libre y fuente abierta.

Lenguaje de propósito general.

Gran cantidad de funciones y librerías.

Sencillo y rápido de programar.

Multiplataforma.

Licencia de código abierto (Opensource).

Orientado a Objetos.

Portable.
Desventajas:

Lentitud por ser un lenguaje interpretado.
60
2.16.10 Lenguaje Ruby
Es un lenguaje interpretado de muy alto nivel y orientado a objetos. Desarrollado
en el 1993 por el programador japonés Yukihiro “Matz” Matsumoto. Su sintaxis
está inspirada en Phyton, Perl. Es distribuido bajo licencia de software
libre (Opensource).
Ruby es un lenguaje dinámico para una programación orientada a objetos rápida y
sencilla. Para los que deseen iniciarse en este lenguaje pueden encontrar un
tutorial interactivo de ruby. Se encuentra también a disposición de estos usuarios
un sitio con informaciones y cursos en español.
Características:

Existe diferencia entre mayúsculas y minúsculas.

Múltiples expresiones por líneas, separadas por punto y coma “;”.

Dispone de manejo de excepciones.

Ruby puede cargar librerías de extensiones dinámicamente si el (Sistema
Operativo) lo permite.

Portátil.
Ventajas:

Permite desarrollar soluciones a bajo Costo.

Software libre.

Multiplataforma.
61
2.17 TEGNOLOGIAS UTILIZADAS EN EL SISTEMA
2.17.1 PHP
PHP es un acrónimo recursivo que significa PHP Hypertext Pre-processor. Fue
creado originalmente por Rasmus Lerdorf en 1994; sin embargo la implementación
principal de PHP es producida ahora por “The PHP Group” y sirve como el
estándar de facto para PHP al no haber una especificación formal. Publicado bajo
la Free Software Foundation se considera esta licencia como software libre.
Puede ser desplegado en la mayoría de los servidores web y en casi todos
los sistemas operativos y plataformas sin costo alguno. El lenguaje PHP se
encuentra instalado en más de 20 millones de sitios web y en un millón de
servidores, el número de sitios en PHP ha compartido algo de su preponderante
sitio con otros nuevos lenguajes no tan poderosos desde agosto de 2005. Este
mismo sitio web de Wikipedia está desarrollado en PHP. Es también el módulo
Apache más popular entre las computadoras que utilizan Apache como servidor
web.
El gran parecido que posee PHP con los lenguajes más comunes
de programación
estructurada,
como C y Perl,
permiten
a la
mayoría
de
los programadores crear aplicaciones complejas con una curva de aprendizaje
muy corta. También les permite involucrarse con aplicaciones de contenido
dinámico sin tener que aprender todo un nuevo grupo de funciones.
Aunque todo en su diseño está orientado a facilitar la creación de sitios
webs, es posible crear aplicaciones con una interfaz gráfica para el usuario,
utilizando la extensión PHP-Qt oPHP-GTK. También puede ser usado desde
la línea de órdenes, de la misma manera como Perl o Python pueden hacerlo; a
esta versión de PHP se la llama PHP-CLI.
62
Cuando el cliente hace una petición al servidor para que le envíe
una página web, el servidor ejecuta el intérprete de PHP. Éste procesa
el script solicitado que generará el contenido de manera dinámica (por ejemplo
obteniendo información de una base de datos). El resultado es enviado por el
intérprete al servidor, quien a su vez se lo envía al cliente. Mediante extensiones
es también posible la generación de archivos PDF, Flash, así como imágenes en
diferentes formatos.
Permite la conexión a diferentes tipos de servidores de bases de datos tales
como MySQL,PostgreSQL, Oracle, ODBC, DB2.
XAMPP es un servidor independiente de plataforma, software libre, que
consiste principalmente en la base de datos MySQL, el servidor Web Apache y los
intérpretes para lenguajes de script: PHP y Perl. El nombre proviene del acrónimo
de X (para cualquiera de los diferentes sistemas operativos), Apache, MySQL,
PHP, Perl. El programa está liberado bajo la licencia GNU y actúa como un
servidor Web libre, fácil de usar y capaz de interpretar páginas dinámicas.
Actualmente XAMPP está disponible para Microsoft Windows, GNU/Linux, Solaris,
y MacOS X.
PHP también tiene la capacidad de ser ejecutado en la mayoría de
los sistemas operativos, tales como Unix (y de ese tipo, como Linux o Mac OS X)
y Microsoft Windows, y puede interactuar con los servidores de web más
populares ya que existe en versión CGI, módulo para Apache, e ISAPI.
Ventajas

Es un lenguaje multiplataforma.

Orientado al desarrollo de aplicaciones web dinámicas con acceso a
información almacenada en una base de datos.
63

El código fuente escrito en PHP es invisible al navegador web y al cliente ya
que es el servidor el que se encarga de ejecutar el código y enviar su resultado
HTML al navegador. Esto hace que la programación en PHP sea segura y
confiable.

Capacidad de conexión con la mayoría de los motores de base de datos que
se utilizan en la actualidad, destaca su conectividad con MySQL y PostgreSQL.

Capacidad de expandir su potencial utilizando módulos (llamados ext's o
extensiones).

Posee una amplia documentación en su sitio web oficial, entre la cual se
destaca que todas las funciones del sistema están explicadas y ejemplificadas
en un único archivo de ayuda.

Es libre, por lo que se presenta como una alternativa de fácil acceso para
todos.

Permite aplicar técnicas de programación orientada a objetos.

Biblioteca nativa de funciones sumamente amplia e incluida.

No requiere definición de tipos de variables aunque sus variables se pueden
evaluar también por el tipo que estén manejando en tiempo de ejecución.

Tiene manejo de excepciones (desde PHP5).

Si bien PHP no obliga a quien lo usa a seguir una determinada metodología a
la hora de programar (muchos otros lenguajes tampoco lo hacen), aun
haciéndolo, el programador puede aplicar en su trabajo cualquier técnica de
programación o de desarrollo que le permita escribir código ordenado,
estructurado y manejable. Un ejemplo de esto son los desarrollos que en PHP
se han hecho del patrón de diseño Modelo Vista Controlador(MVC), que
permiten separar el tratamiento y acceso a los datos, la lógica de control y
la interfaz de usuario en tres componentes independientes.
Inconvenientes

Como es un lenguaje que se interpreta en ejecución, para ciertos usos puede
resultar un inconveniente que el código fuente no pueda ser ocultado.
64
La ofuscación es una técnica que puede dificultar la lectura del código pero no
la impide y, en ciertos casos, representa un costo en tiempos de ejecución.
2.17.2 MYSQL
Es un sistema de gestión de bases de datos relacional, multihilo y multiusuario con
más de seis millones de instalaciones.1 MySQL AB —desde enero de 2008 una
subsidiaria de Sun Microsystems y ésta a su vez de Oracle Corporation desde
abril de 2009— desarrolla MySQL como software libre en un esquema de
licenciamiento dual.
Por un lado se ofrece bajo la GNU GPL para cualquier uso compatible con
esta licencia, pero para aquellas empresas que quieran incorporarlo en productos
privativos deben comprar a la empresa una licencia específica que les permita
este uso. Está desarrollado en su mayor parte en ANSI C.
Al contrario de proyectos como Apache, donde el software es desarrollado
por una comunidad pública y los derechos de autor del código están en poder del
autor individual, MySQL es patrocinado por una empresa privada, que posee el
copyright de la mayor parte del código.
Esto es lo que posibilita el esquema de licenciamiento anteriormente
mencionado. Además de la venta de licencias privativas, la compañía ofrece
soporte y servicios. Para sus operaciones contratan trabajadores alrededor del
mundo
que
colaboran
vía Internet.
MySQL
AB
fue
fundado
Axmark, Allan Larssony Michael Widenius.
Características de la versión

Un amplio subconjunto de ANSI SQL 99, y varias extensiones.

Soporte a multiplataforma.

Procedimientos almacenados

Disparadores (triggers).

Vistas actualizables.
65
por David

Soporte a VARCHAR

INFORMATION_SCHEMA

Modo Strict

Soporte X/Open XA de transacciones distribuidas; transacción en dos fases
como parte de esto, utilizando el motor InnoDB de Oracle.

Motores de almacenamiento independientes (MyISAM para lecturas rápidas,
InnoDB para transacciones e integridad referencial).

Transacciones con los motores de almacenamiento InnoDB, BDB Y Cluster;
puntos de recuperación (savepoints) con InnoDB.

Soporte para SSL.

Query caching

Sub-SELECTs (o SELECTs anidados).

Réplica con un maestro por esclavo, varios esclavos por maestro, sin soporte
automático para múltiples maestros por esclavo.

Búsqueda de campos de texto completos usando el motor de almacenamiento
MyISAM.

Embedded database library

Soporte completo para Unicode.

Conforme a las reglas ACID usando los motores InnoDB, BDB y Cluster.

Shared-nothing clustering through MySQL Cluster.
66
CAPÍTULO 3
67
3.1 DESARROLLO DEL SISTEMA DE PROGRAMACION
ACADEMICA DE LA FACULTAD DE CONTADURIA Y
ADMINISTRACIÓN
68
BORRAR EXPERIENCIA EDUCATIVA
function selecion(){
$con=mysql_query("select *from materia");
echo '
<form name="form2" method="post" action="AM.php?var=3">
Buscar Tutor <select name="select">';
while( $row=mysql_fetch_array($con))
{
echo "<option value='".$row[0]."'>".$row[1]."</option>";
}
echo'<input name="borrar" type="submit"></form>';
if($_POST['borrar']){
$id=$_POST['select'];
echo $id;
mysql_query("delete from materia where id_materia='$id'");
{echo "<p>Elemento Borado</p>";}
}
}
Este script permite seleccionar una experiencia educativa por nombre, y poder
eliminarla de la base de datos.
69
IMPORTAR EXPERIENCIA EDUCATIVA
function formulario( ){
echo
<form
action="convertir.php"
method="post"
enctype="multipart/form-data">
<input name="archivo" type="file" size="35" />
70
<input
name="enviar"
type="submit"
value="Upload File"
/> <input name="action" type="hidden value="upload"
/>
</form>';
}
Este script permite llamar
a otro script (converit.php) el cual realiza la
importación de datos desde una Hoja de Excel a la base de datos mysql.
71
ALTA DE EXPERIENCIA EDUCATIVA
function agregar(){
echo '
<table > <tr>
<td width="80" scope="row">ID <td width="175"><label>
<input type="text" name="id" id="matricula" value= ""> </label></td> </tr>
<tr>
< td scope="row"> E.Educativa <td><label> <input type="text" name="materia"
id="" value="" />
72
</label></td> </tr>
<td scope="row"> Creditos
<td><label>
<input type="text" name="creditos" id="" value=""/>
</label></td> </tr>
<tr>
<td scope="row">Requisito
<td><label>
<input type="text"
name="requisito" id="" value=""/>
</label></td>
</tr>
<tr><td scope="row">Carrera<td>
<label>
<select name="carrera" id="carrera">
<option value="1">Sistemas Comp. Admin.</option>
<option value="2">Contaduria</option>
<option value="3">Administracion</option>
<option value="4">Ges. y Dir. de Negocios</option>
</select></label> </td> </tr>
<tr>
<td scope="row">Bloque<td>
<label>
<select name="bloque" id="semestre">
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option><option value="4">4</option>
value="5">5</option>
<option value="6">6</option>
<option value="7">7</option>
<option value="8">8</option>
<option value="9">9</option>
73
<option
</select>
</label>
</td>
</tr>
<td scope="row">
<tr>
<td><label>
<input type="submit" name="enviar" id="button" value="Guardar" />
</label></td></tr></td>
La función agregar genera
</table>';} ?>
un formulario de registro de nuevas experiencias
educativas, y los almacena en la base de datos.
EXPLORAR OPCIONES EXPERIENCIAS EDUCATIVAS
<?php
if($_GET['var']==2){agregar();}
if($_GET['var']==3){selecion();}?>
<?php if($_GET['var']==1){formulario();}?>
74
Este script genera dinámicamente las opciones referentes a los formularios que
se muestran según la opción elegida por el usuario.
ALTA TUTOR
<?php
include("conexion.php");
if(isset($_POST['enviar'])){
//variables
$id=$_POST['id'];
75
$nombre=$_POST['nombre'];
$apellidos=$_POST['apellidos'];
//Guardar Datos
$consulta=mysql_query("insert into tutor values('$id','$nombre','$apellidos')");
}
Este script procesa los datos enviados por el formulario de alta a tutores y utiliza
parámetros para almacenar los datos personales de un cada tutor.
76
MODIFICAR TUTOR
if(isset($_POST['busca'])){
$id=$_POST['select'];
$consulta=mysql_query("select *from tutor where id_tutor='$id'");
77
$est=mysql_fetch_array($consulta);
$id=$est['0'];
$nombre=$est[1];
$apellido=$est[2];
}
?>
Este código extrae los datos de un tutor especificado por el ID ,y lo asigna a un
formulario que permite realizar modificaciones posteriormente.
CONSULTA TUTOR
<?php }
if((isset($_GET['var2']))&&($_GET['var2']=2)){
$con=mysql_query("select *from tutor");
?>
<form name="form2" method="post" action="AT.php?var2=2">
<p>Buscar Tutor <select name="select"><?php
while( $row=mysql_fetch_array($con))
{
78
echo
"<option
value='".$row[0]."'>".$row[1].
"
".$row[2]."</option>";
}?>
Este
script da la opción de consultar la información de un tutor ,mediante la
selección por nombre de los mismos.
79
BORRAR TUTOR
<?php if((isset($_GET['var3']))&&($_GET['var3']=3)){
$con=mysql_query("select *from tutor");
?>
<form name="form3" method="post" action="AT.php?var3=3">
<p>Buscar Tutor
<select name="select">
<?php
while( $row=mysql_fetch_array($con))
echo "<option value='".$row[0]."'>".$row[1]. {
".$row[2]."</option>";
}?>
</select>
<input name="borrar" type="submit" value="Borrar">
</p>
</form> <?php
if(isset($_POST['borrar'])){
$id=$_POST['select'];
$a=mysql_query("delete from tutor where id_tutor='$id'");
if($a){echo "Elemento Borado";}
}} ?>
80
Este script realiza consulta a la base de datos y extrae los datos del tutor
especificado para posteriormente borrar el registro adecuado.
ALTA ESTUDIANTE
<?php include("conexion.php");
$matricula=$_POST['matricula'];
$nombre=$_POST['nombre'];
$paterno=$_POST['paterno'];
$materno=$_POST['paterno'];
$carrera=$_POST['carrera'];
$semestre=$_POST['semestre'];
$consulta=mysql_query("insert
into
estudiante
values('$matricula','$nombre','$paterno','$materno','$carrera',$semestre)"); ?>
Este script toma como variables los datos del formulario de alta estudiante para
crear un registro en la base de datos.
81
MODIFICAR ESTUDIANTE
<?php include("conexion.php");
if(!isset($_POST['enviar'])){
$matricula=$_POST['matricula'];
$nombre=$_POST['nombre'];
$paterno=$_POST['paterno'];
$materno=$_POST['materno'];
$carrera=$_POST['carrera'];
$semestre=$_POST['semestre'];
$consulta=mysql_query("update estudiante set matricula='$matricula',
nombre='$nombre',apellido_paterno='$paterno',
apellido_materno='$materno',carrera='$carrera',semestre='$semestre'
where
matricula='$matricula'");
}
?>
Este script realiza la consulta a la base de datos de un estudiante para extraer sus
datos para poder realizar modificaciones.
82
BORRAR ESTUDIANTE
<?php include("conexion.php");
if(!isset($_POST['Borrar'])){
$matricula=$_POST['matricula'];
$consulta=mysql_query("Delete from estudiante where matricula='$matricula'”);
}
?>
Este script permite
a cada estudiante, eliminar su información personal del
sistema. En caso de ser necesario crear otra cuenta.
83
INGRESAR/CONSULTAR CALIFICACIONES
<?php if($_GET['var']==3){
$con=mysql_query("select
,historial.materia_id_materia
from
historial
INNER
materia.nombre_materia
JOIN
materia
historial.materia_id_materia=materia.id_materia
ON
where
historial.estudiante_materia='$materia");
if($con){echo'si';}
echo '
<form name="form1" method="post" action="IC.php?var=3">
<label></label>
<select name="select2" size="1" id="select2">';
while( $row=mysql_fetch_array($con))
{
echo "<option value='".$row[0]."'>".$row[1]."</option>";
}
echo '</select>
<input type="submit" name="ver1" id="button" value="Ver" />
</form>';
}
84
?>
<table width="216" border="0">
<tr>
<td width="10" height="26" scope="row">
<td width="196">
<label>
<?php if(isset($_GET['var2'])&&($_GET['var2']=2)){ ?>
<form action="IC.php" method="post">
<select name="select1" size="1" id="select1">
<option selected="selected" value="1">Primero</option>
<option value="2">Segundo</option>
<option value="3">Tercero</option>
<option value="4">Cuarto</option>
</select>
</label>
<input type="submit" name="ver" id="button" value="Ver" />
</form><?php }?>
<?php if(isset($_GET['var1'])&&($_GET['var1']=1)){?>
<form name="form1" method="post" action="">
85
<label></label>
<select name="select2" size="1" id="select2">
<?php
$con=mysql_query("select
*from
materia
where
programa_id_programa='12'");
while( $row=mysql_fetch_array($con))
{
echo "<option value='".$row[0]."'>".$row[1]."</option>";
}
?>
</select>
<input type="submit" name="ver1" id="button" value="Ver" />
</form>
<?php } ?>
Este script permite generar dos formularios u opciones para que el alumno pueda
capturar en el sistema su historial académico.
86
CONSULTA DE HISTORAL Y PROGRAMACION ACADEMICA
<?php include("conexion.php");
if(isset($_POST['consultar'])){
$matricula=$_POST['matricula'];
$materia=$_POST['materia'];
$carrera=$_POST['carrera'];
//$con=mysql_query("create
view as prueba AS select *from estudiante where
matricula like '$clave%'");
87
mysql_query("drop view prueba");
$con2=mysql_query("create view prueba AS select *from historial where
estudiante_matricula like '$matricula%' AND materia_id_materia!='$materia'");
$con=mysql_query("select *from estudiante RIGHT JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula
estudiante.carrera='$carrera'");
//while($imp=mysql_fetch_array($con)){
//echo $imp[0]."<p>";
}
function consulta(){
$con=mysql_query("select *from materia");
echo ' <select name="materia">';
while( $row=mysql_fetch_array($con))
{
echo "<option
value='".$row[0]."'>".$row[1]."</option>";
}
echo'</form>'; }?>
<?php if($_POST['consultar']){?>
<table width="430" height="63" border="1">
<tr>
<th width="74" height="31" scope="col">Matricula</th>
<th width="271" scope="col">Nombre</th>
<th width="63" scope="col">Semestre</th>
</tr><?php $i=1; while($row=mysql_fetch_array($con)){
88
WHERE
?>
<tr bgcolor= <?php if(($i%2)==0){ echo"#CCCCCC";}?> >
<td><center>
<span class="Estilo6"><b><font color="#000000"><?php echo $row[0];?>
</b></span></font>
</center></td>
<td><span class="Estilo6"><b><center><font color="#000000"><?php echo
$row[1]." ".$row[2]." ".$row[3]?></center></b></span></font></td>
<td><span
class="Estilo6"><b><center><font
color="#000000"><?php
$row[6]?></center></b></span></font></td>
</tr>
<?php $i++; }}?>
</table>
Este script realiza todas las opciones de consulta y filtrado de experiencias
educativas, que permite llevar a
cabo el control de programación de carga
académica y demanda de experiencias educativas por parte del usuario principal.
89
CONSULTA ESTUDIANTES Y AVANZE ACADEMICO
<?php if($_POST['consultar']){?>
<table width="430" height="63" border="1">
<tr>
<th width="74" height="31" scope="col">Matricula</th>
<th width="271" scope="col">Nombre</th>
<th width="63" scope="col">Semestre</th>
</tr><?php $i=1; while($row=mysql_fetch_array($con)){
?>
90
<tr bgcolor= <?php if(($i%2)==0){ echo"#CCCCCC";}?> >
<td><center>
<span class="Estilo6"><b><font color="#000000"><?php echo $row[0];?>
</b></span></font>
</center></td>
<td><span class="Estilo6"><b><center><font color="#000000"><?php echo
$row[1]." ".$row[2]." ".$row[3]?></center></b></span></font></td>
<td><span
class="Estilo6"><b><center><font
color="#000000"><?php
$row[6]?></center></b></span></font></td>
</tr>
<?php $i++; }}?>
</table>
Este script permite consultar a cada estudiante su avance o historial académico,
muestra las materias cursadas y pendientes.
91
REPORTES GRAFICOS
<?php // content="text/plain; charset=utf-8"
require_once ('jpgraph/jpgraph.php');
require_once ('jpgraph/jpgraph_bar.php');
92
// Create the graph. These two calls are always required
$graph = new Graph(350,220,'auto');
$graph->SetScale("intint");
mysql_pconnect('localhost','root','root');
mysql_select_db('sistemauv');
$result=mysql_query("select carrera , COUNT(*) AS car from estudiante RIGHT
JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula GROUP BY carrera");
if($result)
//$row=mysql_fetch_assoc($result);
$y=array();
$i=0;
$num=mysql_num_rows($result);
while($row=mysql_fetch_assoc($result)){
if($i<$num){
$y[$i]=$row['car'];
}$i++;}
$x=array("LSCA","LC","LA","LGDN");
//$theme_class="DefaultTheme";
93
//$graph->SetTheme(new $theme_class());
$datay=$y;
// set major and minor tick positions manually
$graph->SetBox(false);
//$graph->ygrid->SetColor('gray');
$graph->ygrid->SetFill(false);
$graph->xaxis->SetTickLabels($x);
$graph->xaxis->SetTickSide(SIDE_BOTTOM);
$graph->xaxis->scale->ticks->Set(2,1.5);
$graph->xaxis->HideTicks(true,true);
$graph->yaxis->HideLine(false);
$graph->xaxis->HideLine(false);
$graph->yaxis->HideLine(false);
$graph->yaxis->HideTicks(true,false);
$graph->yaxis->scale->ticks->Set(1,1);
// Create the bar plots
$b1plot = new BarPlot($datay);
94
// ...and add it to the graPH
$graph->Add($b1plot);
$b1plot->SetColor("white");
$b1plot->SetFillGradient("blue","white",GRAD_LEFT_REFLECTION);
$b1plot->SetWidth(45);
//$graph->title->Set('ESTADISTICAS');
$graph->xaxis->title->Set('Programas Educativos');
$graph->yaxis->title->Set('Estudiantes');
// Display the graph
$graph->Stroke();
?>
Este script genera los reportes gráficos del sistema a través de cadenas de
parámetros para la extracción de los datos de la base de datos.
95
CONEXION
<?php
$dbhost="localhost"; // host del MySQL (generalmente localhost)
$dbusuario="root"; // nombre de usuario
$dbpassword="root"; // password de acceso para el usuario de la
$db="sistemauv";
// Base de datos
$conexion = mysql_connect($dbhost,$dbusuario,$dbpassword);
echo mysql_error();
mysql_select_db($db, $conexion);
echo mysql_error();
?>
Este script realiza la conexión principal a la base de datos en MYSQL.
96
REPORTES EN FORMATO PDF
<?php
require('fpdf.php');
class PDF_MySQL_Table extends FPDF
{
97
var $ProcessingTable=false;
var $aCols=array();
var $TableX;
var $HeaderColor;
var $RowColors;
var $ColorIndex;
function Header()
{
//Print the table header if necessary
if($this->ProcessingTable)
$this->TableHeader();
}
function TableHeader()
{
$this->SetFont('Arial','B',12);
$this->SetX($this->TableX);
$fill=!empty($this->HeaderColor);
if($fill)
$this->SetFillColor($this->HeaderColor[0],$this->HeaderColor[1],$this>HeaderColor[2]);
foreach($this->aCols as $col)
$this->Cell($col['w'],6,$col['c'],1,0,'C',$fill);
$this->Ln();
}
98
function Row($data)
{
$this->SetX($this->TableX);
$ci=$this->ColorIndex;
$fill=!empty($this->RowColors[$ci]);
if($fill)
$this->SetFillColor($this->RowColors[$ci][0],$this->RowColors[$ci][1],$this>RowColors[$ci][2]);
foreach($this->aCols as $col)
$this->Cell($col['w'],5,$data[$col['f']],1,0,$col['a'],$fill);
$this->Ln();
$this->ColorIndex=1-$ci;
}
function CalcWidths($width,$align)
{
//Compute the widths of the columns
$TableWidth=0;
foreach($this->aCols as $i=>$col)
{
$w=$col['w'];
if($w==-1)
$w=$width/count($this->aCols);
elseif(substr($w,-1)=='%')
99
$w=$w/100*$width;
$this->aCols[$i]['w']=$w;
$TableWidth+=$w;
}
//Compute the abscissa of the table
if($align=='C')
$this->TableX=max(($this->w-$TableWidth)/2,0);
elseif($align=='R')
$this->TableX=max($this->w-$this->rMargin-$TableWidth,0);
else
$this->TableX=$this->lMargin;
}
function AddCol($field=-1,$width=-1,$caption='',$align='L')
{
//Add a column to the table
if($field==-1)
$field=count($this->aCols);
$this->aCols[]=array('f'=>$field,'c'=>$caption,'w'=>$width,'a'=>$align);
}
function Table($query,$prop=array())
{
//Issue query
$res=mysql_query($query) or die('Error: '.mysql_error()."<BR>Query: $query");
100
//Add all columns if none was specified
if(count($this->aCols)==0)
{
$nb=mysql_num_fields($res);
for($i=0;$i<$nb;$i++)
$this->AddCol();
}
//Retrieve column names when not specified
foreach($this->aCols as $i=>$col)
{
if($col['c']=='')
{
if(is_string($col['f']))
$this->aCols[$i]['c']=ucfirst($col['f']);
else
$this->aCols[$i]['c']=ucfirst(mysql_field_name($res,$col['f']));
}
}
//Handle properties
if(!isset($prop['width']))
$prop['width']=0;
if($prop['width']==0)
$prop['width']=$this->w-$this->lMargin-$this->rMargin;
if(!isset($prop['align']))
$prop['align']='C';
101
if(!isset($prop['padding']))
$prop['padding']=$this->cMargin;
$cMargin=$this->cMargin;
$this->cMargin=$prop['padding'];
if(!isset($prop['HeaderColor']))
$prop['HeaderColor']=array();
$this->HeaderColor=$prop['HeaderColor'];
if(!isset($prop['color1']))
$prop['color1']=array();
if(!isset($prop['color2']))
$prop['color2']=array();
$this->RowColors=array($prop['color1'],$prop['color2']);
//Compute column widths
$this->CalcWidths($prop['width'],$prop['align']);
//Print header
$this->TableHeader();
//Print rows
$this->SetFont('Arial','',11);
$this->ColorIndex=0;
$this->ProcessingTable=true;
while($row=mysql_fetch_array($res))
$this->Row($row);
$this->ProcessingTable=false;
$this->cMargin=$cMargin;
$this->aCols=array();
}} ?>
102
<?php
require('mysql_table.php');
class PDF extends PDF_MySQL_Table
{
function Header()
{ //Title
$this->SetFont('Arial','',12);
$this->Cell(0,6,'REPORTES',0,1,'C');
$this->Ln(10);
//Ensure table header is output
parent::Header();
}
}
//Connect to database
mysql_connect('localhost','root','root');
mysql_select_db('sistemauv');
$pdf=new PDF();
$pdf->AddPage();
//First table: put all columns automatically
$pdf->Table("select matricula ,nombre,apellido_paterno,apellido_materno from
estudiante RIGHT JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula WHERE
estudiante.carrera='".$_GET['carrera']."'");
$pdf->Output();
?>
103
CAPITULO 4
104
Introducción
El capítulo final de esta obra tiene el propósito de delimitar y presentar las
conclusiones obtenidas a partir de los objetivos planteados, y el trabajo elaborado
para la consecución de los mismos. La cual describe los elementos clave que han
sustentado el diseño y desarrollo del sistema de programación académica.
Así mismo se dedica un apartado de recomendaciones las cuales se realizaron a
fin de proponer acciones que si se llevan a cabo brindaran mayores beneficios a
los usuarios del sistema y que son un complemento en futuras referencias.
Por último se anexa un glosario de términos que atiende a la descripción de
terminología mencionada en este proyecto y la cual es un complemento para
facilitar la lectura; Y la bibliografía utilizada para la obtención de la información
aquí presentada.
105
4. 1 Conclusiones y Resultados
El objetivo de esta obra ha sido presentar la planeación y creación de un sistema
de programación académica bajo el enfoque de diseño y programación de
sistemas de información. Concretamente se han detallado los módulos
desarrollados para este proyecto por medio de las distintas tecnologías para
aplicaciones web, mismas que están descritas en capítulos anteriores.
Cabe mencionar que el producto presentado, es decir el sistema que se diseñó,
fue planeado para almacenar los datos relacionados a los estudiantes y su
historial académico, datos de tutores, materias y programas académicos, así
mismo ofrecer las capacidades de consulta y presentación de reportes que
facilitan la labor realizada por el usuario, por lo que se puede señalar que Se
cumple con los requerimientos especificados, en una etapa previa de análisis.
El desarrollo de este proyecto está delimitado a un enfoque de sistemas
convencional, dividido en etapas de ciclo de vida de sistemas, que en este trabajo
son
análisis, diseño y desarrollo. La etapa de análisis es realizada bajo el
enfoque UML, el cual es un estándar de modelado de sistemas, que permite
proporciona una serie de lineamientos que permiten un análisis completo y
versátil. La fase de diseño es realizada a través de lineamientos para la definición
y estructura de datos, implementación de módulos de programación y
maquetación y accesibilidad de aplicaciones. La normalización y propiedades de
las base de datos relacionales forma parte indispensable del Diseño.
Los recursos utilizados para la creación de este sistema, ofrecen características
ideales que brindan ventajas significativas en la creación de un sistema con los
requisitos identificados en este proyecto. En el desarrollo de sistema se integró
lenguajes de programación WEB como lo son HTML, JavaScript, XML, así como
un lenguaje de programación de lado de servidor como lo es PHP, el cual ofrece
una gran flexibilidad y solides a la aplicación, esto permitió crear una aplicación
funcional y escalable a mediano plazo.
106
En relación a esto se menciona que después de finalizar la realización del sistema
de programación Académica se han obtenido los siguientes resultados:

Procesamiento de consultas o filtros específicos de estudiantes, que
permite conocer su condición de inscripción respecto a una experiencia
educativa especifica.

Registro detallado del historial académico de cada estudiante, el cual
permite tener un seguimiento apropiado en próximas inscripciones.

Funciones atribuidas al usuario principal (secretario académico) como lo
son: alta, baja modificaciones de experiencias educativas, tutores y
programas educativos.

Descripción grafica de la demanda de experiencias educativas, de los
distintos programas existentes.

Integración de opciones de registro para los estudiantes y su historial
académico.
Por ultimo cabe mencionar que se ha
realizado un proyecto sólido
y con
posibilidades de crecimiento, el cual brindara diversos beneficios a los usuarios
directos e indirectos. Esperamos sea de gran utilidad y que los beneficios
obtenidos justifiquen su realización.
107
4.2 Recomendaciones
1. Se recomienda realizar revisiones periódicas del sistema, con el objetivo de
realizar modificaciones, mejoras y corrección de errores. Es importante
realizar los cambios de acuerdo a una metodología de programación por
módulos, lo cual traerá beneficios a futuros cambios.
2. Es importante mantener un respaldo del sistema y de los datos
almacenados,
así como un control de versiones, para dar un correcto
seguimiento y mantenimiento al sistema.
3. Integrar el sistema a la base de datos principal de la Universidad
Veracruzana.
4. Implementar módulos de reportes en formatos PDF y un módulo de
exportación de datos a la hoja de cálculos Excel.
108
4.3 Glosario
API: Es el conjunto de funciones y procedimientos o métodos, en la programación
orientada a objetos que ofrece cierta biblioteca para ser utilizado por otro software
como una capa de abstracción.
Aplicación Web: Son aquellas aplicaciones que los usuarios pueden utilizar
accediendo a un servidor web a través de Internet o de una intranet
mediante
un navegador.
Ingeniería de software: Es el área de la ingeniería que ofrece métodos y técnicas
para desarrollar y mantener software. Esta ingeniería trata con áreas muy diversas
de la informática y de las ciencias de la computación.
JavaScript: Es un lenguaje de scripting basado en objetos no tipeado y liviano,
utilizado para acceder a objetos en aplicaciones.
Servidor: Es una computadora que, formando parte de una red, provee servicios a
otras computadoras denominadas clientes.
También se suele denominar con la palabra servidor a: Una aplicación informática
o programa que realiza algunas tareas en beneficio de otras aplicaciones
llamadas clientes. Algunos servicios.
SGBD Son un tipo de software muy específico, dedicado a servir de interfaz entre
la base de datos, el usuario y las aplicaciones que la utilizan.
109
4.4 Bibliografía
Kendall, Kenneth., Kendall, Julie. (2005). Análisis y diseño de sistemas. México:
Pearson educación.
Louden, K. C. (s.f.). Kenneth C. Louden. Ciencias e Ingenierías.
Lancker, L. V. (s.f.). HTML 4: dominar el código fuente. Eni.
Senn, James. (1990). Análisis y diseño de sistemas de información. México: Mc
Graw Hill.
Desarrollo
Web
.
(2009).
Recuperado
el
Octubre
de
2011,
de
http://es.wikipedia.org/wiki/Programaci%C3%
Ángel Cobo, P. G. (s.f.). PHP y MySQL. Tecnología para el desarrollo de
aplicaciones web. Díaz de Santos.
Wikipedia.
(2009).
Recuperado
el
18
de
Octubre
de
2011,
de
Octubre
de
2011,
de
http://es.wikipedia.org/wiki/Programaci%C3%
Desarrollo
Web
.
(2009).
Recuperado
http://es.wikipedia.org/wiki/Programaci%C3%
110
el
Wikipedia.
(2009).
Recuperado
el
18
de
Octubre
de
2011,
http://es.wikipedia.org/wiki/Programaci%C3%
4.5 Anexo
Código del sistema
<?php
include("conexion.php");
if(isset($_POST['enviar'])){
//variables
$id=$_POST['id'];
$nombre=$_POST['nombre'];
$apellidos=$_POST['apellidos'];
//Guardar Datos
$consulta=mysql_query("insert into tutor values('$id','$nombre','$apellidos')");
}
if(isset($_POST['busca'])){
$id=$_POST['select'];
$consulta=mysql_query("select *from tutor where id_tutor='$id'");
$est=mysql_fetch_array($consulta);
$id=$est['0'];
$nombre=$est[1];
111
de
$apellido=$est[2];
}
<script type="text/javascript">
</head><body >
<table
width="100%"
cellspacing="0"
class="bodyborder"
cellpadding="0"
border="0">
<tr>
<td valign="top" align="left" width="100%">
<table width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td width="100%" align="left" valign="top">
<table width="100%" cellspacing="0" cellpadding="2" border="0">
<tr>
<td
valign="middle"
align="center"
width=25
class="status_line" height="17">
<div><a
href="http://www.rickyswebtemplates.com/pmd11_04_00"><img
src="http://www.rickyswebtemplates.com/pmd11_04_00/template/default/images/h
ome.gif" border=0 alt="HOME"></a></div>
</td>
<td valign="middle" align="left" class="status_line">
<div></div>
</td>
112
<td
valign="middle"
align="right"
class="status_line"
height="17">
<div><a
href="http://www.rickyswebtemplates.com/pmd11_04_00/members/user_login.php"
><span class="status_line">Login Now</span></a></div>
</td>
</tr>
</table>
<table width="100%" cellspacing="0" cellpadding="0" border="0">
<tr>
<td
width="50%"
align="left"
valign="top"><img
src="../../../../../Users/TEMP.JuanAntonio-PC.002/Desktop/Documents/SYSTEM
UV/cats.jpg" alt="Universidad Veracruzana" width="105" height="108"><br></td>
<td
width="50%"
align="right"
valign="top"><img
src="../../../../../Users/TEMP.JuanAntonio-PC.002/Desktop/Documents/SYSTEM
UV/lis.png" alt="LIS" width="138" height="100"><br></td>
</tr>
</table>
</td>
</tr>
<tr>
<td width="100%" height="1" bgcolor="#DADADA">
113
<img
src="http://www.rickyswebtemplates.com/pmd11_04_00/template/default/images/pi
xel.gif" alt=""><br>
</td>
</tr>
<tr>
<td valign="middle" align="left" width="100%"><table width="100%"
cellspacing="0" cellpadding="0" border="0">
<tr>
<td valign="top" align="center" width="20%">
<!-- SIDEBOX CODE -->
<br>
<table width="90%" cellspacing="0" cellpadding="5" border="0">
<tr>
<td class="border2" width="100%" height="25" valign=middle align=center>
<p><span class="text">Menu</span></p>
</td>
</tr>
<tr>
<td class="border" width="100%" align="left" valign="top">
<br />
<div class="urbangreymenu">
114
<h3
class="headerbar"><a
href="http://www.dynamicdrive.com/style/">Materias</a></h3>
<ul class="submenu">
<li><a href="AM.php?var=1">Importar</a></li>
<li><a href="AM.php?var=2">Agregar</a></li>
<li><a href="AM.php?var=3">Borrar</a></li>
</ul>
<h3 class="headerbar"><a href="http://www.javascriptkit.com">Tutores</a></h3>
<ul class="submenu">
<li></li>
<li></li>
<li><a href="AT.php?var=1">Alta</a></li>
<li><a href="AT.php?var2=2">Modificacion</a></li>
<li><a href="AT.php?var3=3">Borrar</a></li>
<ul class="submenu">
<li><a href="CF.php">Matricula</a></li>
<li><a href="CF.php?var=2">Alumno</a></li>
<p class="Estilo1">Estudiantes</p>
115
<p><img
src="../../../../../Users/TEMP.JuanAntonio-
PC.002/Desktop/Documents/SYSTEM UV/anigif.gif" alt="Estudiantes" width="201"
height="129"></p></td>
<td valign="top" align="center" width="60%">
<table cellpadding="0" cellspacing="0" border="0" width="100%">
<tr>
<td valign="middle" align="center" width="100%"></td>
</tr>
</table>
<br>
<table width="100%" cellspacing=0 cellpadding=2 border=0>
<tr>
<td
class="border2"
width="100%"
height="25"
valign="middle"
align="center"><p>Estudiantes</p></td>
</tr>
<tr>
<td class="border" width="100%" align="left" valign="top">
<form
name="searchform"
action="http://www.rickyswebtemplates.com/pmd11_04_00/search-all.php"
method="get">
</form>
<script type="text/javascript"><!-document.getElementById('keyword').focus();
116
//--></script>
</td>
</tr>
</table>
<p></p> <?php
if((isset($_GET['var']))&&($_GET['var']=1)){?>
<center> <form id="form1" name="form1" method="post" action="">
<table width="216" border="0">
<tr>
<td width="61" scope="row">ID
<td width="145"><label>
<input type="text" name="id" id="matricula" />
</label></td>
</tr>
<td scope="row">Apellidos<td><label>
<input type="text" name="apellidos" id="paterno" />
</label></td>
</tr>
<tr>
<td scope="row">
117
<td><label>
<input type="submit" name="enviar" id="button" value="Guardar" />
</label></td>
</tr>
</table>
</form></center><?php }
if((isset($_GET['var2']))&&($_GET['var2']=2)){
$con=mysql_query("select *from tutor");
?>
<form name="form2" method="post" action="AT.php?var2=2">
<p>Buscar Tutor <select name="select"><?php
while( $row=mysql_fetch_array($con))
{
echo
"<option
value='".$row[0]."'>".$row[1].
".$row[2]."</option>";
}?>
</select>
<input type="submit" name="busca" id="button2" value="Ver">
</p>
<label></label>
</form>
118
"
<center> <form id="form1" name="form1" method="post" action="">
<table width="216" border="0">
<tr>
<td width="61" scope="row">ID
<td width="145"><label>
<input type="text" name="matricula" id="matricula" value="<?php echo $id;
?>"/>
</label></td></tr>
<td scope="row">Nombre
<td><label>
<input type="text" name="nombre" id="nombre" value="<?php echo
$nombre; ?>" />
</label></td>
</tr>
<tr>
<td scope="row">Apellidos<td><label>
<input type="text" name="paterno" id="paterno" value="<?php echo
$apellido; ?>"/>
</label></td>
</tr>
<tr>
<td scope="row">
119
<td><label>
<input type="submit" name="enviar" id="button" value="Guardar" />
</label></td>
</tr>
</table>
<p> </p>
</form></center> <?php }
?>
<?php if((isset($_GET['var3']))&&($_GET['var3']=3)){
$con=mysql_query("select *from tutor");
?>
<form name="form3" method="post" action="AT.php?var3=3">
<p>Buscar Tutor
<select name="select">
<?php
while( $row=mysql_fetch_array($con))
{
echo
"<option
".$row[2]."</option>";
}?>
120
value='".$row[0]."'>".$row[1].
"
</select>
<input name="borrar" type="submit" value="Borrar">
</p>
</form> <?php
if(isset($_POST['borrar'])){
$id=$_POST['select'];
$a=mysql_query("delete from tutor where id_tutor='$id'");
if($a){echo "Elemento Borado";}
}}
?>
<?php include("conexion.php");
if(isset($_POST['consultar'])){
$matricula=$_POST['matricula'];
$materia=$_POST['materia'];
$carrera=$_POST['carrera'];
//$con=mysql_query("create
view as prueba AS select *from estudiante where
matricula like '$clave%'");
mysql_query("drop view prueba");
$con2=mysql_query("create view prueba AS select *from historial where
estudiante_matricula like '$matricula%' AND materia_id_materia!='$materia'");
121
$con=mysql_query("select *from estudiante RIGHT JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula
WHERE
estudiante.carrera='$carrera'");
//while($imp=mysql_fetch_array($con)){
//echo $imp[0]."<p>";
}
function consulta(){
$con=mysql_query("select *from materia");
echo '
<select name="materia">';
while( $row=mysql_fetch_array($con))
{
echo "<option value='".$row[0]."'>".$row[1]."</option>";
}
echo'</form>';
}?><p><?php consulta();?>
<input type="submit" name="consultar" id="button"
value="Consulta" /></p>
</form><br></td>
</tr>
</table><?php if($_POST['consultar']){?>
122
<table width="430" height="63" border="1">
<tr>
<th width="74" height="31" scope="col">Matricula</th>
<th width="271" scope="col">Nombre</th>
<th width="63" scope="col">Semestre</th>
</tr><?php $i=1; while($row=mysql_fetch_array($con)){
?>
<tr bgcolor= <?php if(($i%2)==0){ echo"#CCCCCC";}?> >
<td><center>
<span class="Estilo6"><b><font color="#000000"><?php echo $row[0];?>
</b></span></font>
</center></td>
<td><span class="Estilo6"><b><center><font color="#000000"><?php echo
$row[1]." ".$row[2]." ".$row[3]?></center></b></span></font></td>
<td><span
class="Estilo6"><b><center><font
$row[6]?></center></b></span></font></td>
</tr>
<?php $i++; }}?>
123
color="#000000"><?php
<?php include("conexion.php");
$matricula=$_POST['matricula'];
$nombre=$_POST['nombre'];
$paterno=$_POST['paterno'];
$materno=$_POST['paterno'];
$carrera=$_POST['carrera'];
$semestre=$_POST['semestre'];
$consulta=mysql_query("insert
into
estudiante
values('$matricula','$nombre','$paterno','$materno','$carrera',$semestre)");?>
<?php include'conexion.php';
$consulta=mysql_query("select *from materia where
bloque_materia=1");
while($mat=mysql_fetch_assoc($consulta)){?>
<tr>
<th scope="row"><div align="center"><?php echo $mat['id_materia'];
?></div></th>
<td><div
align="center"><?php
echo
$mat['nombre_materia'];
align="center"><?php
echo
$mat['creditos_materia'];
?></div></td>
<td><div
?></div></td>
<td></td>
<td> </td>
</tr><?php }?>
124
<?php include("conexion.php");
if(isset($_POST['consultar'])){
$matricula=$_POST['matricula'];
$materia=$_POST['materia'];
$carrera=$_POST['carrera'];
//$con=mysql_query("create
view as prueba AS select *from estudiante where
matricula like '$clave%'");
mysql_query("drop view prueba");
$con2=mysql_query("create view prueba AS select *from historial where
estudiante_matricula like '$matricula%' AND materia_id_materia!='$materia'");
$con=mysql_query("select *from estudiante RIGHT JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula
estudiante.carrera='$carrera'");
//while($imp=mysql_fetch_array($con)){
//echo $imp[0]."<p>";
}
function consulta(){
$con=mysql_query("select *from materia");
echo '
<select name="materia">';
125
WHERE
while( $row=mysql_fetch_array($con))
{
echo "<option value='".$row[0]."'>".$row[1]."</option>";
}
echo'</form>';
}
?>
<?php
require('fpdf.php');
class PDF_MySQL_Table extends FPDF
{
126
var $ProcessingTable=false;
var $aCols=array();
var $TableX;
var $HeaderColor;
var $RowColors;
var $ColorIndex;
function Header()
{
//Print the table header if necessary
if($this->ProcessingTable)
$this->TableHeader();
}
function TableHeader()
{
$this->SetFont('Arial','B',12);
$this->SetX($this->TableX);
$fill=!empty($this->HeaderColor);
if($fill)
$this->SetFillColor($this->HeaderColor[0],$this->HeaderColor[1],$this>HeaderColor[2]);
foreach($this->aCols as $col)
$this->Cell($col['w'],6,$col['c'],1,0,'C',$fill);
$this->Ln();
}
127
function Row($data)
{
$this->SetX($this->TableX);
$ci=$this->ColorIndex;
$fill=!empty($this->RowColors[$ci]);
if($fill)
$this->SetFillColor($this->RowColors[$ci][0],$this->RowColors[$ci][1],$this>RowColors[$ci][2]);
foreach($this->aCols as $col)
$this->Cell($col['w'],5,$data[$col['f']],1,0,$col['a'],$fill);
$this->Ln();
$this->ColorIndex=1-$ci;
}
function CalcWidths($width,$align)
{
//Compute the widths of the columns
$TableWidth=0;
foreach($this->aCols as $i=>$col)
{
$w=$col['w'];
if($w==-1)
$w=$width/count($this->aCols);
elseif(substr($w,-1)=='%')
128
$w=$w/100*$width;
$this->aCols[$i]['w']=$w;
$TableWidth+=$w;
}
//Compute the abscissa of the table
if($align=='C')
$this->TableX=max(($this->w-$TableWidth)/2,0);
elseif($align=='R')
$this->TableX=max($this->w-$this->rMargin-$TableWidth,0);
else
$this->TableX=$this->lMargin;
}
function AddCol($field=-1,$width=-1,$caption='',$align='L')
{
//Add a column to the table
if($field==-1)
$field=count($this->aCols);
$this->aCols[]=array('f'=>$field,'c'=>$caption,'w'=>$width,'a'=>$align);
}
function Table($query,$prop=array())
{
//Issue query
$res=mysql_query($query) or die('Error: '.mysql_error()."<BR>Query: $query");
129
//Add all columns if none was specified
if(count($this->aCols)==0)
{
$nb=mysql_num_fields($res);
for($i=0;$i<$nb;$i++)
$this->AddCol();
}
//Retrieve column names when not specified
foreach($this->aCols as $i=>$col)
{
if($col['c']=='')
{
if(is_string($col['f']))
$this->aCols[$i]['c']=ucfirst($col['f']);
else
$this->aCols[$i]['c']=ucfirst(mysql_field_name($res,$col['f']));
}
}
//Handle properties
if(!isset($prop['width']))
$prop['width']=0;
if($prop['width']==0)
$prop['width']=$this->w-$this->lMargin-$this->rMargin;
if(!isset($prop['align']))
$prop['align']='C';
130
if(!isset($prop['padding']))
$prop['padding']=$this->cMargin;
$cMargin=$this->cMargin;
$this->cMargin=$prop['padding'];
if(!isset($prop['HeaderColor']))
$prop['HeaderColor']=array();
$this->HeaderColor=$prop['HeaderColor'];
if(!isset($prop['color1']))
$prop['color1']=array();
if(!isset($prop['color2']))
$prop['color2']=array();
$this->RowColors=array($prop['color1'],$prop['color2']);
//Compute column widths
$this->CalcWidths($prop['width'],$prop['align']);
//Print header
$this->TableHeader();
//Print rows
$this->SetFont('Arial','',11);
$this->ColorIndex=0;
$this->ProcessingTable=true;
while($row=mysql_fetch_array($res))
$this->Row($row);
$this->ProcessingTable=false;
$this->cMargin=$cMargin;
$this->aCols=array();
}} ?>
131
<?php
require('mysql_table.php');
class PDF extends PDF_MySQL_Table
{
function Header()
{ //Title
$this->SetFont('Arial','',12);
$this->Cell(0,6,'REPORTES',0,1,'C');
$this->Ln(10);
//Ensure table header is output
parent::Header();
}
}
//Connect to database
mysql_connect('localhost','root','root');
mysql_select_db('sistemauv');
$pdf=new PDF();
$pdf->AddPage();
//First table: put all columns automatically
$pdf->Table("select matricula ,nombre,apellido_paterno,apellido_materno from
estudiante RIGHT JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula WHERE
estudiante.carrera='".$_GET['carrera']."'");
$pdf->Output();
?>
132
<?php // content="text/plain; charset=utf-8"
require_once ('jpgraph/jpgraph.php');
require_once ('jpgraph/jpgraph_bar.php');
133
// Create the graph. These two calls are always required
$graph = new Graph(350,220,'auto');
$graph->SetScale("intint");
mysql_pconnect('localhost','root','root');
mysql_select_db('sistemauv');
$result=mysql_query("select carrera , COUNT(*) AS car from estudiante RIGHT
JOIN prueba ON
prueba.estudiante_matricula=estudiante.matricula GROUP BY carrera");
if($result)
//$row=mysql_fetch_assoc($result);
$y=array();
$i=0;
$num=mysql_num_rows($result);
while($row=mysql_fetch_assoc($result)){
if($i<$num){
$y[$i]=$row['car'];
}$i++;}
$x=array("LSCA","LC","LA","LGDN");
//$theme_class="DefaultTheme";
134
//$graph->SetTheme(new $theme_class());
$datay=$y;
// set major and minor tick positions manually
$graph->SetBox(false);
//$graph->ygrid->SetColor('gray');
$graph->ygrid->SetFill(false);
$graph->xaxis->SetTickLabels($x);
$graph->xaxis->SetTickSide(SIDE_BOTTOM);
$graph->xaxis->scale->ticks->Set(2,1.5);
$graph->xaxis->HideTicks(true,true);
$graph->yaxis->HideLine(false);
$graph->xaxis->HideLine(false);
$graph->yaxis->HideLine(false);
$graph->yaxis->HideTicks(true,false);
$graph->yaxis->scale->ticks->Set(1,1);
// Create the bar plots
$b1plot = new BarPlot($datay);
135
// ...and add it to the graPH
$graph->Add($b1plot);
$b1plot->SetColor("white");
$b1plot->SetFillGradient("blue","white",GRAD_LEFT_REFLECTION);
$b1plot->SetWidth(45);
//$graph->title->Set('ESTADISTICAS');
$graph->xaxis->title->Set('Programas Educativos');
$graph->yaxis->title->Set('Estudiantes');
// Display the graph
$graph->Stroke();
?>
136