Ingeniería Software

Mantenimiento de software

Juan Daniel Olguin Panecatl

Docente: Francisco Espinosa

Garita

G-1, VII

Reporte: CRUD (PSP)

Índex

Contenido
Índex ....................................................................................................................... 2
Objetivo ................................................................................................................... 3
Introducción ............................................................................................................. 3
¿Qué es Django? ................................................................................................. 3
¿Cómo funciona Django?................................................................................. 3
Funcionamiento del MTV de Django ................................................................ 4
Contenido ................................................................................................................ 5
Análisis ................................................................................................................ 5
Tabla de planeación ......................................................................................... 5
Planteamiento del problema............................................................................. 5
Solución propuesta. ......................................................................................... 5
Diseño.................................................................................................................. 6
Diagrama de caso de usos............................................................................... 6
Diagrama de secuencia.................................................................................... 7
Codificación ......................................................................................................... 7
Estilos de programación. .................................................................................. 8
Implementación ................................................................................................. 10
Pruebas y registro de tiempos ........................................................................... 11
Tablas de tiempos por fases .......................................................................... 12
Tiempo Real ................................................................................................... 14
Conclusiones ......................................................................................................... 15
Referencias ........................................................................................................... 15

Ilustración 1 Diagrama MVT .................................................................................... 4

Ilustración 2 Diagrama de caso de usos ................................................................. 6
Ilustración 3 Diagrama de Secuencia alta de curso ................................................ 7
Ilustración 4 Código views.py .................................................................................. 8
Ilustración 5 Ejemplo 2 estilo de programación ....................................................... 8
Ilustración 6 Ejemplo 3 estilo de programación ...................................................... 9
Ilustración 7 Muestra 2 clase models.py ................................................................. 9
Ilustración 8 Muestra 2 ejemplo 1............................................................................ 9
Ilustración 9 Interfaz principal ................................................................................ 10
Ilustración 10 Formulario de alta ........................................................................... 10
Ilustración 11 Formato de modificación ................................................................. 11
Ilustración 12 Formato de borrado ........................................................................ 11

Objetivo
Desarrollar un programa para el control de cursos dentro de un sistema educativo.

Introducción
¿Qué es Django?
Django es un framework para aplicaciones web gratuito y open source, escrito en
Python. Es un WEB framework - un conjunto de componentes que te ayudan a
desarrollar sitios web más fácil y rápidamente.
¿Cómo funciona Django?
Django, es un framework MTV (una modificación de MVC), esto se debe a que los
desarrolladores no tuvieron la intención de seguir algún patrón de desarrollo, sino
hacer el framework lo más funcional posible.
Para empezar a entender MTV debemos fijarnos en la analogía con MVC.
 El modelo en Django sigue siendo modelo
 La vista en Django se llama Plantilla (Template)
 El controlador en Django se llama Vista
Ilustración 1 Diagrama MVT

Funcionamiento del MTV de Django

Veamos que hace cada uno de ellos con un poco más de detalle y algunos
conceptos adicionales.
El modelo
El modelo define los datos almacenados, se encuentra en forma de clases de
Python, cada tipo de dato que debe ser almacenado se encuentra en una variable
con ciertos parámetros, posee métodos también. Todo esto permite indicar y
controlar el comportamiento de los datos.
La vista
La vista se presenta en forma de funciones en Python, su propósito es determinar
qué datos serán visualizados, entre otras cosas más. El ORM de Django permite
escribir código Python en lugar de SQL para hacer las consultas que necesita la
vista. La vista también se encarga de tareas conocidas como el envío de correo
electrónico, la autenticación con servicios externos y la validación de datos a
través de formularios. Lo más importante a entender con respecto a la vista es que
no tiene nada que ver con el estilo de presentación de los datos, sólo se encarga
de los datos, la presentación es tarea de la plantilla.
La plantilla
La plantilla es básicamente una página HTML con algunas etiquetas extras
propias de Django, en si no solamente crea contenido en HTML (también XML,
CSS, JavaScript, CSV, etc.).
La plantilla recibe los datos de la vista y luego los organiza para la presentación al
navegador web. Las etiquetas que Django usa para las plantillas permiten que sea
flexible para los diseñadores del frontend, incluso tiene estructuras de datos como
if, si es necesaria una presentación lógica de los datos, estas estructuras son
limitadas para evitar un desorden poniendo cualquier tipo de código Python.
Contenido
Análisis
Tabla de planeación
Etapa Fecha inicio Fecha Fin Tiempo

Análisis 06/11/17 07/11/17 4Hrs

Diseño 07/11/17 07/11/17 2Hrs

Implementación 08/11/17 08/11/17 2Hrs

y codificación

Pruebas 08/11/17 08/11/17 30 Min

Planteamiento del problema

Después de saber cómo funciona el framework a emplear vamos a pasar a el
planteamiento del problema.
A continuación, se presentan el planteamiento del problema, para el cual se
consideraron los siguientes pasos previos:
 Enfocar el tema (documentarnos individualmente acerca de los procesos de
la gestión de cursos)
 Puntos Base (Se realizaron puntos de inicio, manera de preguntas claras y
concisas, con el fin de obtener información objetiva, esto agilizaría el
proceso).
 Redactar la información a manera de texto para que posteriormente el
modelado del proyecto fuese correcto.
Solución propuesta.
Se propone dar solucion al problema utilizando Django y Python todo ello
aprovechando el patrón MVT propuesto por Django. Entonces partiendo de ese
punto vamos a establecer nuestro diseño, dado el tamaño del sistema solo vamos
a realizar diagrama de caso de usos, diagrama de secuencia para conocer la
comunicación.
Diseño
Diagrama de caso de usos

Ilustración 2 Diagrama de caso de usos

Diagrama de secuencia

Ilustración 3 Diagrama de Secuencia alta de curso

Nota: El diagrama describe el proceso de alta de un curso, pero es aplicable para el

resto de funciones.
Codificación
Para la parte de codificación se van a tomar en cuenta lo propuesto por los
estándares de programación en Python (PEP8) a continuación se ejemplifican,
mostrando parte de la codificación.
Estilos de programación.

Ilustración 4 Código views.py

 En dicho ejemplo se respeta la normativa que indica que no se deberá

exceder un máximo de 79 caracteres por línea de código.

Ilustración 5 Ejemplo 2 estilo de programación

 Para la segunda muestra se puede notar que para importar varios archivos
es necesario alinear e identar cada uno de ellos por otro lado se puede
apreciar que donde se abre paréntesis se alinea al que cierra.
Ilustración 6 Ejemplo 3 estilo de programación

 Para la 3ra muestra se puede apreciar que cuando es requerido importar más
de una clase de debe importar una por línea en lugar de ser separado por
comas como se acostumbra a hacer.

Ilustración 7 Muestra 2 clase models.py

Para la 2da muestra se plantean los siguientes estándares de programación:

Ilustración 8 Muestra 2 ejemplo 1

 El siguiente estándar dicta que la declaración de variables, así como la

igualación de estas deberá ser separada por un espacio entre el signo y la
igualación.

 Finalmente se ejemplifica el estándar de nombramiento de variables que

indica que si una variable está compuesta por dos palabras la segunda
deberá iniciar con mayúscula.
Estos son algunos ejemplos de los estilos de programación.
Implementación
A continuación, se muestran los resultados de la implementación.

Ilustración 9 Interfaz principal

Ahora vamos a mostrar los 4 componentes básicos es decir “create, read, update
delete”

Ilustración 10 Formulario de alta

Ilustración 11 Formato de modificación

Ilustración 12 Formato de borrado

Nota: la imagen de muestra para lectura no es mostrada, pues ello se ve en la

interfaz de inicio.
Nota 2: La interfaz para registro y modificación es la misma exceptuando, que para
modificar los datos son regresados a los campos del formulario.
Pruebas y registro de tiempos
Finalmente vamos a la etapa de pruebas y tiempos invertidos en cada fase del
proyecto.
Tablas de tiempos por fases
Etapa: Análisis Nombre del proyecto: CRUD

Nombre(s) del realizador(es): Juan Daniel Olguín Panecatl Versión: 1.0

y Dani Omar Cuellar

Comienzo Fin Tiempo de Tiempo Actividad Comentarios

interrupción total

06/11/17 10:20 12:00 20 Min 1:20H Investigación Se llevó acabo la

investigación de todas
la herramientas a
utilizar.

07/11/17 10:20 11:10 10 Min 40Min Planteamiento S/C

del problema

07/11/17 11:10 12:00 5 Min 45Min Propuesta de S/C

solución.

Etapa: Diseño Nombre del proyecto: CRUD

Nombre(s) del realizador(es): Juan Daniel Olguín Panecatl Versión: 1.0

Fecha Comienzo Fin Tiempo de Tiempo Actividad Comentarios

interrupción total

07/11/17 12:00 12:20 S/T 20M Diag. Casos Se llevó acabo por
Usos Juan Daniel Olguin

07/11/17 12:20 12:50 10 Min 20Min Diag. Se llevó acabo por

Secuencia Juan Daniel Olguin
Etapa: Codificación e implementación Nombre del proyecto: CRUD

Nombre(s) del realizador(es): Juan Daniel Olguín Panecatl Versión: 1.0

y Dani Omar Cuellar

Fecha Comienzo Fin Tiempo de Tiempo Actividad Comentarios

interrupción total

08/11/17 8:00 8:30 S/T 30M Módulo de Se llevó acabo por

alta Juan Daniel Olguin

08/11/17 8:30 9:00 10 Min 20M Modulo Se llevó acabo por

lectura Juan Daniel Olguin

08/11/17 9:00 9:30 10 Min 20M Módulo de Se llevó acabo por

edición Dani Omar

08/11/17 9:30 10:00 5 Min 25M Módulo de Se llevó acabo por

borrado Dani Omar

Etapa: Pruebas Nombre del proyecto: CRUD

Nombre(s) del realizador(es): Juan Daniel Olguín Panecatl Versión: 1.0

y Dani Omar Cuellar

Fecha Comienzo Fin Tiempo de Tiempo Actividad Comentarios

interrupción total

08/11/17 12:50 12:55 S/T 5M Módulo de Se llevó acabo por

alta Juan Daniel Olguin

08/11/17 12:55 13:00 S/T 5M Modulo Se llevó acabo por

lectura Juan Daniel Olguin

08/11/17 13:00 13:05 10 Min 5M Módulo de Se llevó acabo por

edición Dani Omar

08/11/17 13:05 13:10 5 Min 5M Módulo de Se llevó acabo por

borrado Dani Omar
Tabla de defectos

Fecha Numero Tipo Inyección Eliminación Tiempo de Tiempo Descripción

reparación de
defecto

08/11/17 1 Codificación e Se creó 08/11/17 5 Min 5 Min No se consideró la base de

implementación conexión datos que establece por
de base defecto Django
de datos
MySQL

08/11/17 2 Codificación e Corrección 08/11/17 10 Min 10 Min No se consideró tomar el

implementación en el identificador para realizar el
borrado borrado.

Tiempo Real
Etapa Fecha inicio Fecha Fin Tiempo Tiempo Muerto
productivo

Análisis 06/11/17 07/11/17 3:41Hrs 35 Min

Diseño 07/11/17 07/11/17 40Hrs 10 Min

Implementación 08/11/17 08/11/17 1:35Hrs 25 Min

y codificación

Pruebas 08/11/17 08/11/17 20 Min S/TM

Conclusiones
Como primera conclusión es indispensable decir que llevar un control de tiempos
generar una mayor producción pues al ser evaluado, se analizan los tiempos
productivos y tiempos muertos con esta información podemos realizar
optimizaciones en el proceso para mejor los tiempos.
Para finalizar el implementar estándares de código permite que el sistema pueda
ser retomado en un futuro, pues el código será entendible y escalables gracias a los
estándares y patrones de programación.

Referencias
[1] Sergio Infante Montero. (2012). Entendiendo como trabaja Django. 2017, de
Maestros de la web Sitio web: http://www.maestrosdelweb.com/curso-django-
entendiendo-como-trabaja-django/