“Buenas prácticas en el desarrollo de proyectos de software
106
UNIVERSIDAD POLITÉCNICA DE SINALOA PROGRAMA ACADÉMICO DE INGENIERÍA EN INFORMÁTICA Tesina “Buenas prácticas en el desarrollo de proyectos de software” Para cumplir la acreditación de las estadías profesionales y contar con los créditos necesarios para obtener el grado de Ingeniero en Informática Autor: Carlos Alfredo Ortega Morales Asesor: M.C. Rosa Angélica Rosales Camacho Asesor OR: Ing. Erick Baz Hernández
Transcript of “Buenas prácticas en el desarrollo de proyectos de software
UNIVERSIDAD POLITÉCNICA DE SINALOA PROGRAMA ACADÉMICO DE
INGENIERÍA EN INFORMÁTICA
Tesina
“Buenas prácticas en el desarrollo de proyectos de software”
Para cumplir la acreditación de las estadías profesionales y contar con los créditos necesarios para obtener el grado de Ingeniero en Informática
Autor:
Carlos Alfredo Ortega Morales
Asesor:
M.C. Rosa Angélica Rosales Camacho
Asesor OR:
Ing. Erick Baz Hernández
Carta de aceptación de estadías
Carta de liberación de estadías
Carta de aceptación de tema de tesina
Carta de aprobación y digitalización de tesina
Agradecimientos
Esta sección, se la dedico a mis padres y hermana, los cuales me han apoyado
durante toda mi vida, me han dado las herramientas necesarias para seguir en
momentos difíciles, brindarme la calidad humana con la que he crecido y ser
pacientes a pesar de mis caídas.
Ellos siempre me han dado la inspiración de seguir mis deseos sin
importar que tan difícil sea el camino que recorrer para cumplirlos, por supuesto, sin
dañar la integridad de los terceros. Darme confianza en las decisiones que todo día a
día y motivarme a tener más logros cada vez que consigo cumplir uno.
Índice temático CAPÍTULO 1 INTRODUCCIÓN ................................................................................. 1
Introducción ................................................................................................................. 2
Antecedentes .............................................................................................................. 3
Planteamiento del problema ........................................................................................ 4
Hipótesis...................................................................................................................... 5
Objetivos ..................................................................................................................... 5
General .................................................................................................................... 5
Específicos ............................................................................................................... 5
Importancia y/o justificación del estudio ...................................................................... 6
Limitaciones del estudio .............................................................................................. 7
Definición de términos ................................................................................................. 8
CAPÍTULO 2 MARCO REFERENCIAL Y MARCO TEORICO .................................. 9
Descripción y análisis de investigaciones relacionadas ............................................ 11
Construcción del software, una etapa importante .................................................. 13
Metáforas ............................................................................................................... 14
La planificación ...................................................................................................... 16
Manejo de cambios durante la construcción .......................................................... 18
Lenguaje de programación .................................................................................... 20
Eligiendo el lenguaje de programación a utilizar .................................................... 23
Características de un buen diseño ......................................................................... 24
Niveles de diseño ................................................................................................... 26
Uso de ADT (Abstract Data Type).......................................................................... 28
Beneficios de usar ADT ......................................................................................... 29
Razones por las cuales crear una clase ................................................................ 30
Razones por la cual crear una rutina. .................................................................... 32
Como nombrar a una rutina. .................................................................................. 34
JavaScript .............................................................................................................. 36
CSS ........................................................................................................................ 37
Control de versiones .............................................................................................. 38
MSSQL .................................................................................................................. 39
Infraestructura .Net ................................................................................................ 41
Infraestructura .Net Core ........................................................................................ 44
C# .......................................................................................................................... 45
ASP.NET MVC ....................................................................................................... 47
Entity Framework ................................................................................................... 49
Sumario ..................................................................................................................... 51
CAPÍTULO 3 METODOLOGIA ................................................................................ 52
Herramientas ........................................................................................................... 54
IDE (Integrated Development Enviroment) ............................................................ 54
jQuery .................................................................................................................... 55
Bootstrap ................................................................................................................ 57
SSMS ..................................................................................................................... 59
Git .......................................................................................................................... 60
Procedimiento ......................................................................................................... 62
Introducción a ASP.NET MVC con Entity Framework. ........................................... 62
Obtener información de la base de datos. ............................................................. 72
Uso de anotaciones de datos ................................................................................. 75
Manejo de vistas .................................................................................................... 77
Respaldo de aplicación en GitHub ......................................................................... 79
CAPÍTULO 4 RESULTADOS .................................................................................. 83
Análisis de datos ....................................................................................................... 84
CAPÍTULO 5 DISCUSIÓN ....................................................................................... 87
Conclusiones ............................................................................................................. 88
Recomendaciones y/o sugerencias ........................................................................... 89
Bibliografía ................................................................................................................ 90
Índice de figuras
Figura 1. Actividades comúnmente realizadas en el desarrollo de software ............. 12
Figura 2. CLR en conjunto con otras tecnologías de Microsoft. ................................ 43
Figura 3. Funcionalidad interna de Entity Framework para el acceso a datos. ......... 50
Figura 4. Logotipo de Visual Studio. .......................................................................... 54
Figura 5. Logotipo de jQuery. .................................................................................... 55
Figura 6. Logotipo de Bootstrap. ............................................................................... 57
Figura 7. Logotipo de SSMS. .................................................................................... 59
Figura 8. Logotipo de Git. .......................................................................................... 60
Figura 9. Creación de un nuevo proyecto. ................................................................ 62
Figura 10. Selección del tipo de proyecto a crear. .................................................... 63
Figura 11. Establecimiento de la estructura del proyecto. ......................................... 63
Figura 12. Generación de la estructura del proyecto. ................................................ 63
Figura 13. Estructura del proyecto generada. ........................................................... 64
Figura 14. Creación de un modelo en ASP.NET (Paso 1). ....................................... 64
Figura 15. Creación de un modelo en ASP.NET (Paso 2). ....................................... 65
Figura 16. Creación de un modelo en ASP.NET (Paso 3). ....................................... 65
Figura 17. Asignación de atributos a un modelo. ...................................................... 66
Figura 18. Abrir la línea de comandos del administrador de paquetes. ..................... 66
Figura 19. Habilitar migraciones en el proyecto. ....................................................... 67
Figura 20. Creación de una migración en ASP.NET. ................................................ 67
Figura 21. Estructura de una migración (Función Up). .............................................. 68
Figura 22. Estructura de una migración (Función Down). ......................................... 68
Figura 23. Clase ApplicationDbContext en la estructura de la aplicación. ................ 69
Figura 24. Creacion del DbSet para el modelo en ApplicationDbContext. ................ 69
Figura 25. Configuración de la cadena de conexión a BD en el archivo web.config. 70
Figura 26. Ejecución de las migraciones para estructurar la base de datos. ............ 70
Figura 27. Abrir el explorador de objetos de SQL Server. ......................................... 71
Figura 28. Base de datos en el servidor. ................................................................... 71
Figura 29. Controlador utilizado para las secciones genérico en ASP.NET. ............. 72
Figura 30. Estructura general de un repositorio. ....................................................... 73
Figura 31. Uso de repositorios dentro de un controlador. ......................................... 74
Figura 32. Anotaciones de datos en los atributos de un modelo. .............................. 75
Figura 33. Vista validada con las anotaciones de datos. ........................................... 76
Figura 34. Vista utilizando Razor View Engine. ......................................................... 77
Figura 35. Vista validada con jQuery validator. ......................................................... 78
Figura 36. Acceso al explorador de equipos. ............................................................ 79
Figura 37. Conexión a GitHub (Paso 1). ................................................................... 79
Figura 38. Conexión a GitHub (Paso 2). ................................................................... 80
Figura 39. Acciones permitidas dentro de un repositorio Git. .................................... 80
Figura 40. Guardar los cambios en el repositorio. ..................................................... 81
Figura 41. Sincronizar los cambios en el repositorio. ................................................ 81
Figura 42. Publicar los cambios en el repositorio. ..................................................... 82
Figura 43. Costos de implementación de cambios en base al tiempo. ...................... 85
Índice de tablas
Tabla 1. Típicas prácticas aplicadas a tres tipos comunes de proyectos de software.
.................................................................................................................................. 17
Tabla 2. Lenguajes de programación más utilizados en base al índice TIOBE ......... 20
Tabla 3. Ventajas y desventajas de la librería jQuery. .............................................. 56
Tabla 4. Ventajas y desventajas del Framework Bootstrap ....................................... 58
Resumen
El desarrollo de proyectos de software se está requiriendo en empresas de alto nivel
de competitividad, con el objetivo de obtener mejores ganancias aplicando
inteligencia de negocios.
Con esto, los desarrolladores de software, deben de contar con técnicas
que ayuden a la optimización en el desarrollo, con el objetivo de cumplir con los
tiempos de entrega. De esta manera, los tiempos de entrega se cumplirán como lo
planeado y los clientes se encontrarán satisfechos.
La definición del problema, las tecnologías a utilizar para el desarrollo
del nuevo sistema, y aplicación de buenas prácticas en la programación, hacen que
un software sea exitoso. La construcción es más que solo programar y depurar. Es
planificar un diseño, realizar pruebas unitarias y de integración, y realizar un plan de
cómo se llevará a cabo la construcción.
Palabras clave: Construcción, software, buenas prácticas
Abstract
The development of software Project is being required in companies of high level of
competitiveness, with the objective of obtain better incomes applying business
intelligence.
With this, developers, must know techniques that help to optimize the
construction, with the objective to present on delivery times. In this way, delivery
times are going to be achieved and clients are going to feel satisfied by the results.
The definition of the problem, the technologies to use to develop the
system and applying best practices during programming, help to make a project
successful. The construction isn’t just programming and debugging. It is a detailed
design, unit and integration testing and construction planning.
Key words: Software, Construction, best practices.
CAPÍTULO 1
INTRODUCCIÓN
2
Introducción
El desarrollo de software en las empresas se inició desde la época de los sesenta,
aproximadamente. La implementación se inició con sistemas conocidos como
planificación de requerimientos materiales (MRP por sus siglas en ingles) [1], y hasta
la época de los noventa se da a la luz los sistemas de planificación de recursos
empresariales (ERP por sus siglas en ingles) [2]. Siendo estos tipos de sistemas tan
grandes y con tantos servicios a un sistema de negocios empresarial.
Los desarrolladores de estos grandes sistemas tienen que implementar
una metodología correcta para el enfoque de la empresa, buenas prácticas en la
producción del software, aplicar las diferentes pruebas en el mismo y establecer la
metáfora que ayude al desarrollo del mismo. Implementando estos puntos, se puede
llegar a generar un software de calidad y con los mejores tiempos de entrega
posibles.
Planificar la estructura de una base de datos, la implementación de la
aplicación, los patrones de diseño a utilizar, los objetos a abstraer, el manejo de
control de versiones, etcétera, son aplicables en los puntos antes mencionados para
el desarrollo de la investigación. Utilizando estos puntos con tecnologías Microsoft,
ayudan que el desarrollo se vuelva más fluido durante la construcción de la
aplicación.
3
Antecedentes
Paralelo al surgimiento de MRP, nació la famosa metodología conocida como
Cascada (Waterfall) [3] , con la cual se establece el algoritmo a seguir para realizar
un proyecto de software de manera exitosa. Sin embargo, en esa época todavía
faltaba establecerse mejores técnicas para desarrollo, es decir, faltaba establecer
estándares de codificación y estructuras bien definidas de un lenguaje específico.
Entre los mejores libros sobre buenas prácticas en el desarrollo de software que se
conocen hoy en día esta Code Complete 2. [4].
4
Planteamiento del problema
Cuando se desarrolla un software, entre el 30% y el 80% del trabajo realizado se
basa en su construcción (Programar, Depurar, etc.) [5].
Un desarrollador debe ver la forma de solucionar el problema al cliente
en cuestión y no enfocarse tanto en cómo desarrollar el software. El desarrollo del
software no se basa solamente en obtener la solución específica para cada usuario,
si no ver la manera de como el equipo de trabajo pueda trabajar de manera más
cómoda y dinámicamente posible, para evitar el estrés por los tiempos de entrega y
los malos entendidos de la estructura de trabajo.
Ese tipo de problemas establece un tiempo extra a trabajar ya que el
software no se entrega a tiempo y normalmente no resulta como se esperaba al
momento de la planeación.
Es por eso que se recomienda realizar una buena planeación al
momento de empezar un proyecto de software (no sobre planearlo, ya puede
consumir más tiempo de lo debido) [6] para poder establecer las formas de trabajo y
tener la idea clara de lo que se desea realizar, evitando pasar por caminos no
establecidos.
Con esto, se puede llegar a realizar un proyecto donde todos los
involucrados terminen satisfechos (en especial el cliente).
5
Hipótesis
Una buena planeación y la aplicación de buenas prácticas en el desarrollo de
software, ayuda al equipo de trabajo comprender lo que se desea realizar y mejorar
la forma de trabajo, llevando a un desarrollo profesional y dinámico.
Objetivos
General
Establecer un criterio de trabajo profesional en el desarrollo de proyectos de software
sin importar el área.
Específicos
o Establecer la metáfora para el problema a solucionar con el software a crear.
o Realizar una buena planeación para un proyecto.
o Desarrollar un software aplicando las buenas prácticas.
o Realizar un código limpio para su fácil comprensión.
6
Importancia y/o justificación del estudio
La ciencia de la computación cuenta con un amplio vocabulario a pesar de su corto
tiempo [7], ya que se encarga de abstraer el mundo real en programas de
computadoras que ayuden a facilitar los procesos a realizar día a día en el trabajo y
hogar.
Para ello, se debe de desarrollar por parte de los “constructores de
software” una lógica para poder representar de manera entendible para el
computador y el usuario un software que cumpla con los requerimientos. Además,
realizar un buen análisis, se tiene que realizar una buena construcción del mismo,
aplicando las técnicas que se establecieron en el análisis, así como utilizar las
bondades que ofrece el lenguaje de programación utilizado, ya que el
desconocimiento del lenguaje conlleva más tiempo del planeado y un desfase en las
fechas de entrega.
Las buenas prácticas en la codificación y abstracción del problema en
una metáfora siempre son las que ayudan a realizar un buen producto de software.
Ya que con la metáfora establecida se comprende muy bien la idea de lo que quiere
el cliente y con las buenas prácticas aprovechar las bondades del lenguaje de
programación a utilizar sin importar el enfoque.
7
Limitaciones del estudio
Debido a que las ciencias de la computación no cuentan con tanto tiempo de
existencia como lo son otras ciencias exactas e inexactas como medicina,
arquitectura, matemáticas, química biología, etcétera, no se puede saber a ciencia
cierta cómo se debe de resolver un problema de la mejor manera.
Encontrar una solución perfecta nunca es tan sencillo para un problema
en específico, por lo que se considera utilizar como lo dicen la “fuerza bruta” [8], una
solución que pueda resolver el problema de manera rápida mientras se encuentra
una mejor.
8
Definición de términos
Software: Conjunto de programas, instrucciones y reglas informáticas para ejecutar
ciertas tareas en una computadora [9]. En otras palabras, el concepto de software
abarca a todas las aplicaciones informáticas, como los procesadores de textos, las
planillas de cálculo y los editores de imágenes [10].
Sistema de información: Serie de componentes que se interrelacionan con el objetivo
de recopilar, procesar, almacenar y transmitir información como soporte a los niveles
directivos dentro de la organización, auxiliando en la toma de decisiones, el control,
el análisis y la coordinación [11].
Empresa: Unidad económico-social, integrada por elementos humanos, materiales y
técnicos, que tiene el objetivo de obtener utilidades a través de su participación en el
mercado de bienes y servicios [12].
MRP: Sistema de planificación y administración, normalmente asociado con un
software que planifica la producción y un sistema de control de inventarios [13].
ERP: Sistemas de información gerenciales que integran y manejan muchos de los
negocios asociados con las operaciones de producción y de los aspectos de
distribución de una compañía en la producción de bienes o servicios [14].
Metodología cascada: También conocido como modelo clásico, modelo tradicional o
modelo lineal secuencial. Él método de la cascada es considerado como el enfoque
clásico para el ciclo de vida del desarrollo de sistemas, se puede decir que es un
método puro que implica un desarrollo rígido [15].
Metáfora: Se trata de la aplicación de un concepto o de una expresión sobre una idea
o un objeto al cual no describe de manera directa, con la intención de sugerir una
comparación con otro elemento y facilitar su comprensión [16].
CAPÍTULO 2
MARCO REFERENCIAL Y MARCO
TEORICO
10
El desarrollo de software por parte de profesionistas es algo que se ha convertido en
crítico para el crecimiento de una empresa. Esto hace que los expertos en el
desarrollo del software se estén actualizando día con día, ya que siempre surge una
mejor manera de solucionar un problema. Un mejor criterio se obtiene al momento de
extender el conocimiento y aplicar las bases aprendidas de libros en la vida real.
Pero no solo se trata de practica como muchos programadores lo
hacen, también se trata de pesar en un plan de trabajo que determine cómo, por qué
y para que aplicar una estrategia, con el objetivo de desarrollar el proyecto de
software de la mejor manera posible, en tiempos de entrega considerables y sin
preocupaciones.
Ya que el tiempo de construcción es la etapa que consume más tiempo
en el desarrollo de software, es aquí donde los expertos toman en cuenta las
diferentes técnicas, o como lo llaman “trucos”, para el desarrollo de aplicaciones. La
base de datos, el enfoque de programación, los diferentes servidores y consumos en
servicios que tendrán, etcétera. Esto con el objetivo de hacerlos funcionar como uno
solo y poder crear un software de calidad.
11
Descripción y análisis de investigaciones relacionadas
Programar, depurar, probar, planear y muchas otras palabras en el desarrollo de
software, son utilizadas para nombrar las actividades y características que deben de
cumplir un software en base a sus requerimientos.
Durante los últimos 25 años, investigadores en el desarrollo de software
han identificado diferentes actividades [17].
Algunas de ellas son:
Definición del problema.
Desarrollo de requerimientos.
Planeación de la construcción.
Definición de la arquitectura de software.
Diseño detallado.
Programación y compilación.
Pruebas unitarias.
Pruebas de integración.
Integración.
Pruebas de sistema.
Mantenimiento correctivo.
Varias de estas actividades conforman un proceso conocido como
construcción, que es después de la planeación. Pero para aquellos desarrolladores
que han trabajado en proyectos informales, la construcción les recuerda a programar
y depurar. Esa definición es incorrecta, ya que sin las demás actividades la
construcción carecería de certeza si no se desarrollaran las otras actividades.
Para explicar más detallado, programación se refiere a trasladar un
diseño ya existente en un leguaje de computadora [18]. Por lo que si no existe un
diseño no hay nada que programar. Pero dirán que en un proyecto lo más tardado es
siempre codificar y compilar. Eso es cierto, pero dentro de la construcción no está
solamente esas dos actividades, dentro de ellas también se encuentran el diseño
12
detallado, pruebas unitarias, plan de construcción, integración y pruebas de
integración también conocidas como pruebas de desarrollador.
En la siguiente figura se puede mostrar de manera gráfica las
actividades realizadas dentro del desarrollo de software, donde las que implican la
construcción están dentro del círculo gris.
Figura 1. Actividades comúnmente realizadas en el desarrollo de software
Fuente: Code Complete 2nd Edition, Steve McConnell, Capitulo 1, Pagina 4.
13
Construcción del software, una etapa importante
Como toda persona, los desarrolladores mejoran el día a día cuando ponen en
práctica sus conocimientos, encontrando siempre una mejor manera de resolver los
problemas que le presentan los clientes, con necesidades de resolverlos con un
software.
Dentro del desarrollo de un software, la construcción siempre se lleva la
mayor parte del tiempo, ya que esta toma entre el 30% y 80% del tiempo total
requerido para la finalización del proyecto (como se mencionó en el Capítulo 1).
Uno de los productos obtenidos dentro de la construcción, es lo que se
conoce como código fuente, estará actualizado, ya que las especificaciones de los
requerimientos y la documentación del diseño pueden des-actualizarse fácilmente.
El código será la documentación disponible para los programadores.
Con esto, tiene que contar con una buena calidad [19]. Por lo cual, se requiere que
se apliquen técnicas de consistencia para mejorar el código fuente, para que este
sea legible y no tener la necesidad de preguntar por la lógica de negocios al cliente
de manera recurrente.
Además, dentro del desarrollo de software, la etapa de la construcción
está garantizada que será terminada. En un mundo perfecto, un proyecto de
software, primero iniciara estableciendo cuidadosamente los requerimientos y la
arquitectura a utilizar antes de empezar la construcción del mismo. Pero en el mundo
real, con frecuencia se saltan los requerimientos y el diseño para empezar
directamente con la construcción. Así como la omisión de pruebas provocan muchos
errores que consumen demasiado tiempo corregir.
14
Metáforas
Cuando se trata de entender algo, la mejor opción es compararlo con algo que ya se
conoce. Un ejemplo, en matemáticas, cuando nos enseñan las tablas de multiplicar,
al principio no sabemos por qué 8 x 7 = 56, y para comprenderlo el profesor nos dice
que si sumamos siete veces ocho el resultado será cincuenta y seis. Esta manera de
pensar es cuando aplicamos las metáforas. Y aplicar este tipo de metáforas se les
conoce como modelar.
En las metáforas siempre existirá una que se aplique mejor a un
problema que otra. Las buenas metáforas son simples, se relaciona bien con otras
metáforas relevantes, y explica mucho de la evidencia experimental y otros
fenómenos observados.
Una metáfora se trata de la aplicación de un concepto o de una
expresión sobre una idea o un objeto al cual no describe de manera directa, con la
intención de sugerir una comparación con otro elemento y facilitar su comprensión.
En el software, una metáfora nunca dirá en dónde buscar la respuesta,
esta dice como buscarla. Una metáfora sirve más para la heurística que como
algoritmo.
Hay que recordar bien que un algoritmo es grupo finito de operaciones
organizadas de manera lógica y ordenada que permite solucionar un determinado
problema [20]. Un algoritmo, por tanto, es predecible, determinístico y no está sujeto
a la casualidad.
Cuando se empieza a programar, lo más difícil es siempre
conceptualizar el problema. Por lo general los errores en programación son errores
conceptuales [21].
Con esto se resume a que cada programa es conceptualmente único.
Ya que es imposible crear una solución para poder resolver múltiples problemas, la
solución va a cambiar de alguna manera.
15
La manera de usar las metáforas es para dar una percepción de los
problemas de programación y sus procesos. Estás ayudan a pensar en las
actividades de programación y encontrar mejores maneras de realizar las cosas.
16
La planificación
Definiendo los requisitos de un proyecto de software, es considerado en estos
tiempos, no ser tan necesario para empezar a construir un software.
Se puede determinar que no es necesario, pero en base a
investigaciones realizadas desde los años setenta hasta la fecha, se demuestra que
los proyectos son más fáciles de desarrollar si una preparación adecuada de
actividades es hecha antes de que la construcción del software comience [22].
Además, el objetivo general de la preparación es la reducción de
errores. Un buen plan limpia los errores problemáticos del camino lo más rápido
posible para que el proyecto pueda ser trabajado fluidamente.
Construir un proyecto de software es como cualquier otro proyecto que
consume personal y dinero. Por ejemplo, cuando se construye una casa, primero se
hacen los planos de la arquitectura antes de empezar a poner los ladrillos. El tener
un plan técnico cuenta mucho como en el software.
Una de las ideas principales en programación efectiva es que la
preparación es importante. Desde un punto de vista administrativo, planificar significa
determinar la cantidad de tiempo, número de personas y número de computadoras
que el proyecto va a necesitar. Desde un punto de vista técnico, planificar significa
comprender que es lo que se quiere construir con el objetivo de no desperdiciar
recursos construyendo la idea incorrecta [23].
Determinar en qué tipo de proyecto se está trabajando
Diferentes tipos de proyectos llaman a diferentes balances entre la preparación y la
construcción. Cada proyecto es único, pero los proyectos tienden a caer en un estilo
de desarrollo general.
En la siguiente tabla se muestran los tipos de proyectos comunes y la
lista de las prácticas que son las mejores para cada tipo de proyecto.
17
Tabla 1. Típicas prácticas aplicadas a tres tipos comunes de proyectos de software.
Fuente: Code Complete 2nd Edition, Steve McConnell, Pagina 31, Capitulo 3
18
Manejo de cambios durante la construcción
Los requerimientos estables son el santo grial del desarrollo de software [24].
Teniendo en un proyecto requerimientos estables, se pueden realizar las siguientes
actividades de manera ordenada y calmada. Siempre los consumos son predecibles,
no existen preocupaciones sobre costos altos por implementar características que al
cliente se le ocurrieron después de terminar de depurar.
Pero en un mundo real, el problema no es que los clientes tengan un
ciclo de vida corto durante el proyecto. Mientras más se trabaja en el proyecto, mejor
se comprende, mientras los clientes trabajen más con el equipo de trabajo, también
lo entenderán mejor. El proceso de desarrollo ayuda a los clientes entender mejor
sus necesidades, y esta es la mayor fuente de cambios en los requerimientos.
Algunas sugerencias para manejar los cambios de requerimientos
durante la construcción se mencionarán a continuación:
Asegurarse de hacer conocer el costo por el cambio de requerimientos.
Los clientes se emocionan cuando piensan en nuevas características. En su
emoción, olvidan todas las juntas donde se discutieron los requerimientos y el
documento donde se establecieron. La mejor manera de manejarlo es
aceptándole la idea, pero advirtiéndole que se agendara para después para
poder calcular los costos de implementación de esas nuevas características.
Las palabras “costos” y “agendar” lo harán reconsiderar sus ideas.
Mantener la visión dentro del caso de negocios del proyecto.
Muchos problemas de requerimientos desaparecen antes de recordar la razón
de negocios por la cual se está realizando el proyecto.
Destruye el proyecto.
Si los requerimientos son malos o volátiles, es mejor cancelar el proyecto. Si
no se puede cancelar el proyecto, es bueno pensar como seria si se
cancelara, también cuanto tiempo tiene que pasar para que el proyecto
empiece a empeorar, con el objetivo de cancelarlo.
19
Utilizar la lista de requerimientos al final de cada sección para asegurar la
calidad de los requerimientos.
Si los requerimientos no son tan buenos, es mejor parar, regresar y mejorarlos
antes de continuar.
20
Lenguaje de programación
Un lenguaje de programación es un lenguaje diseñado para describir el conjunto de
acciones consecutivas que un equipo debe ejecutar. Por lo tanto, un lenguaje de
programación es un modo práctico para que los seres humanos puedan dar
instrucciones a un equipo [25].
Estos cuentan con diferentes enfoques en base al proyecto que se vaya
a desarrollar, con el objetivo de que el desarrollo se realice lo más fácil posible y que
todo cuente con una dirección correcta.
Dentro de los lenguajes de programación que existen en la actualidad,
se menciona la lista de los lenguajes más utilizados en base al índice TIOBE (las
siglas de “The Importance of Being Earnest”).
Lenguaje Descripción
Assembly Language También llamado “asembled”, tipo de
lenguaje de bajo nivel en el cual cada
línea de código corresponde a una
instrucción de máquina.
C Es un lenguaje de medio nivel con
propósito general que fue asociado
originalmente con el sistema operativo
UNIX.
C++ Lenguaje de programación orientado a
objetos basado en C. Fue desarrollado
en Laboratorios Bell en los años 80. Es
compatible con C.
Java Lenguaje de programación orientado a
objetos con una sintaxis similar a C y
Tabla 2. Lenguajes de programación más utilizados en base al índice TIOBE
21
C++ que fue desarrollado por Sun
Microsystems, Inc. Fue diseñado para
que sus aplicaciones trabajen en
cualquier plataforma convirtiendo el
código fuente en códigos de byte, el
cual es ejecutado en cada plataforma
dentro de un ambiente conocido como
máquina virtual.
Phyton Es un lenguaje interpretado, interactivo
y orientado a objetos que puede ser
ejecutado en diferentes ambientes. Es
utilizado comúnmente para generar
scripts y pequeñas aplicaciones, pero
también soporta crear aplicaciones
grandes.
C# Lenguaje de propósito general,
orientado a objetos y ambiente de
programación desarrollado por
Microsoft con sintaxis similar a C, C++
y Java.
Visual Basic .Net Lenguaje de programación orientado a
objetos que se puede considerar una
evolución de Visual Basic
implementada sobre el framework
.NET.
JavaScript Es un lenguaje interpretado de script
que era erróneamente relacionado con
Java. Es utilizado principalmente en
programación del lado del cliente para
22
agregar funciones y aplicaciones en
línea en páginas web.
PHP Es un lenguaje de programación de
script código libre con una sintaxis
similar a Perl, Bourne, Shell,
JavaScript y C. Se ejecuta en la
mayoría de los sistemas operativos
para proveer funciones utilizadas del
lado del servidor.
El índice TIOBE es un informe mensual que elabora y publica la empresa TIOBE
Software BV.
TIOBE Software BV es una empresa afincada en Eindhoven, Holanda, que se ha
encargado de desarrollar y mejorar desde el año 2001 un algoritmo basado en la
ejecución de infinidad de queries en los mayores motores de búsqueda del mundo
(Google, MSN, Yahoo!, Baidu, Wikipedia o YouTube, entre otros). Con los resultados
obtenidos, su algoritmo es capaz de cuantificar el uso en el mundo de los distintos
lenguajes de programación [26].
Source: http://noticias.universia.com.ar/consejos-profesionales/noticia/2016/02/22/1136443/conoce-cuales-lenguajes-programacion-populares.html
23
Eligiendo el lenguaje de programación a utilizar
El lenguaje de programación que se utiliza para implementar el sistema, debe de ser
de gran interés para los programadores, ya que ellos serán los que estarán inmersos
en él desde el principio de la construcción hasta el final del proyecto.
Los programadores son más productivos utilizando lenguajes que
sepan utilizar más que lenguajes que les parezcan desconocidos. Datos obtenidos
del modelo de estimación Cocomo II que los programadores que han utilizado un
lenguaje por tres años o más son alrededor de 30% más productivos a
programadores que son principiantes en el lenguaje [27].
Además, los programadores que trabajan con lenguajes de alto nivel
tienen una mejor productividad que aquellos que trabajan con lenguajes de bajo
nivel.
Los programadores son influenciados ciertamente por sus lenguajes de
programación. Las palabras disponibles en un lenguaje para representar ideas,
determinan como expresa sus pensamientos el programador y que pensamientos
puede expresar.
Otro punto a considerar son los factores tecnológicos que existen al
momento de seleccionar el respectivo lenguaje. Si existe un lenguaje de
programación que te facilite y provee herramientas que exente tener problemas con
la tecnología que se encuentra en el mercado, utilizar el lenguaje no sería una mala
idea.
24
Características de un buen diseño
Un diseño de buena calidad tiene muchas características generales. Si estas metas
se logran, el diseño estaría muy bien establecido. Muchas metas contradicen otras,
pero eso es el reto del diseño, crear un buen conjunto de intercambios de los
objetivos competidos.
Se listan las características del diseño [28]:
Mínima complejidad: El principal objetivo del diseño es minimizar la complejidad
de un proyecto. Es mejor evitar hacer diseños inteligentes. Diseños “inteligentes”
son más difíciles de comprender. Es mejor hacer diseños “simples” y “fáciles de
comprender”. Si el diseño se encuentra conectado con la gran mayoría de las
partes del programa cuando se está diseñando una parte específica, entonces el
diseño no está haciendo su trabajo.
Pocas relaciones: Significa mantener el número mínimo de conexiones entre las
diferentes partes del programa. En este aspecto es bueno utilizar los principios
de buena abstracción en las interfaces de las clases, encapsulación e
información anónima para diseñar clases con el menor número de
interconexiones posibles.
Extensibilidad: Con extensibilidad se refiere a la posibilidad de poder mejorar un
programa sin afectar la estructura del mismo.
Reusabilidad: Define el diseñar el sistema con el objetivo de poder utilizar
partes del mismo en otros sistemas.
Alta gama de librerías: Esto se refiere, como su nombre lo indica, a tener un
gran número de librerías que puede utilizar una clase. Esto implica que el
sistema fue diseñado para hacer buen uso de clases de utilidad a niveles bajos
del sistema.
Portabilidad: Se define como: diseñar un sistema con el objetivo de poder
utilizar partes del mismo en otro sistema.
Eficiencia: Esto se refiere en diseñar el sistema con el objetivo de que este no
cuente con partes adicionales. Voltaire dijo que un libro es terminado no cuando
nada más puede ser agregado sino cuando nada más puede ser retirado.
25
División en capas: Algo bueno es tratar de mantener los niveles de
descomposición clasificados de manera que el sistema se pueda ver de un solo
nivel y poder obtener una vista consistente.
26
Niveles de diseño
En diferentes niveles del desarrollo de un sistema, el diseño es requerido. Muchos
aplican a uno dos niveles mientras que buenos diseños aplican a todos los niveles.
Los niveles se describirán a continuación.
Nivel 1: Sistema de software.
El primer nivel abarca el sistema completo. Muchos programadores brincan del nivel
del sistema directamente al diseño de clases, pero es recomendable pensar desde
un alto panorama en cuestiones de combinación de clases, subsistemas o paquetes.
Nivel 2: División entre subsistemas o paquetes.
El propósito principal del diseño en este nivel es la identificación de todos los
subsistemas con los que contara el sistema principal. Los subsistemas pueden ser:
Base de datos, interfaz de usuario, reglas de negocios, interprete de comandos,
generador de reportes, etcétera. En este mismo nivel se definen como cada
subsistema va interactuar con los otros subsistemas.
Una particularidad importante dentro de este nivel es definir las reglas
de como los subsistemas se van a comunicar entre sí. Si todos los subsistemas se
comunican con todos los subsistemas, entonces se pierde el beneficio de separarlos
a todos.
El subsistema tiene que ser significativo con comunicaciones
restringidas. Esto se hace con el objetivo de no crear una telaraña de
comunicaciones entre diferentes subsistemas y al momento de dar mantenimiento o
corregir errores, el tener que comprender de nuevo una parte del sistema sea muy
complejo.
27
Nivel 3: División entre clases.
El diseño en este nivel conlleva identificar todas las clases que contendrá el sistema.
La manera en que cada clase interactúa con el resto del sistema también es
especificada en este nivel.
Sobre todo, la mayor actividad a realizar en este nivel es asegurase
que todos los subsistemas han sido descompuestos a un nivel fino de detalle lo
suficiente para que esas partes puedan ser implementadas de manera individual sin
depender de otras.
Nivel 4: División en rutinas.
En este nivel se incluye dividir las diferentes clases obtenidas del diseño de nivel 3
en rutinas. La interfaz de la clase definirá varias de estas rutinas. El definir las
rutinas de una clase ayuda al entendimiento de la clase.
Nivel 5: Diseño interno de la rutina.
El diseño al nivel de rutina consiste en componer la funcionalidad detallada de cada
rutina. Por lo general, el diseño interno de una rutina se deja a criterio de los
programadores que trabajaran en las rutinas. El diseño consiste en actividades
como escribir el pseudocódigo, búsqueda de algoritmos que sirvan para las rutinas,
como organizar el código en la rutina y con base a todo esto, escribir el código para
la rutina. Este nivel de diseño siempre se cumple en todos los proyectos.
28
Uso de ADT (Abstract Data Type)
La programación que utiliza abstracción de datos se basa en el hecho de que en un
programa se deben integrar y combinar los tipos básicos de datos, como números y
caracteres, para formar estructuras de datos más complejas y así representar
información dentro del computador. En general existe una fuerte relación entre todos
los datos manipulados por un programa, por lo que es conveniente que esa relación
esté claramente especificada y controlada, de forma que cada parte del programa
"vea" sólo lo que necesita.
Esto último es muy importante para separar el programa en partes
independientes, o módulos, evitando así que los cambios en una parte produzcan
errores en otras partes del programa. Por ejemplo, en un programa que usa varios
arreglos y matrices para almacenar información, es frecuente que al aumentar el
tamaño de una dimensión se olvide aumentar se olvide aumentar los otros arreglos,
por lo que el mantenimiento del programa es más difícil. El objetivo perseguido al
usar abstracción de datos es lograr aislar todas estas dependencias, de forma que
los cambios puedan ser hechos con un mínimo de esfuerzo y en una forma
localizada. En nada ayuda tener que buscar por todo el programa en qué lugar debe
hacerse cada cambio [29].
Al usar abstracción de datos el programador define cómo puede
comportarse cada una de las variables de su programa. O sea que además de usar
abstracción de procedimientos para construir el programa modularmente, deben
especificarse las operaciones válidas sobre los datos. El objetivo es programar
módulos que definan nuevos tipos de datos, y además que incluyan varios
procedimientos (operaciones) que permitan manipularlos. Este par (procedimiento y
dato) se le conoce como Tipo Abstracto de Datos (ADT por sus siglas en ingles). El
programador es usuario del ADT podrá manipular las variables únicamente por
medio de sus procedimientos asociados. En un sólo módulo se "encapsula" el nuevo
tipo de datos junto con sus procedimientos.
29
Beneficios de usar ADT
Algunos de los beneficios de utilizar ADT se listan a continuación [30]:
Se pueden ocultar detalles de implementación.
Ocultar información acerca de la fuente de datos significa que el tipo de dato cambia,
solamente se tiene que cambiar en un solo lugar sin tener que afectar todo el
programa. Ocultar la información también protege el resto del programa si se decide
almacenar información de un lugar externo en vez de en memoria o para sobrescribir
todas las rutinas de manipulación en otro lenguaje.
Los cambios no afectan todo el programa.
Los cambios solo se hacen en un solo lugar con el objetivo de que no afecten el resto
del programa.
Las interfaces son más informativas.
Un código como fuenteActual.Size = 12, es ambiguo ya que el tamaño podría ser en
pixeles o en puntos. El contexto no dice cual está utilizando. Recolectando todas las
operaciones similares dentro de un ADT permite definir toda la interfaz en términos
de puntos, pixeles o para diferenciar claramente entre los dos, que evita la confusión
con los mismos.
Es más fácil de mejorar el rendimiento.
Si se necesita mejorar el rendimiento, se pueden recodificar un menor número de
rutinas bien definidas en vez de entrar dentro del todo el programa.
El programa se vuelve más documentado.
Ya que esto requiere que las funciones sean descriptivas por sí mismas, hace que el
programa sea más fácil de entender sin tener que leer el código, al menos si no es
requerido o no se tenga que modificar la función.
30
Razones por las cuales crear una clase
La razón más conocida por la cual crear clases es para modelar objetos de la vida
real. Pero en la vida real, existen muchas otras razones por la cual crear clases y
algunas de estas se mencionarán a continuación.
Modelan objetos abstractos.
Las clases permiten modelar objetos que no son considerados en concreto como
objetos en el mundo real, pero pueden dar una abstracción de otros objetos en
concreto. Un ejemplo de ello sería una clase llamada Forma. Las figuras circulo y
cuadrado si existen, pero Forma es una abstracción de esas y de muchas otras
figuras.
Reducen la complejidad.
La razón más importante por la cual crear una clase es para reducir la complejidad
de un programa. Es bueno crear una clase para ocultar información y no necesitar
pensar en ello. Claro que se pensara en ello cuando se esté codificando. Pero
cuando se encuentra terminada, se pueden olvidar los detalles y poder utilizarla sin
ningún conocimiento de su funcionamiento interno.
Reduce el tamaño del código.
El reducir el tamaño del código siempre es bueno en cualquier programa, desde que
se inició la implementación de rutinas en los lenguajes de programación fue lo que
impulso a la reutilización del código. Las clases permiten lo mismo, y con ello
permiten que el mantenimiento sea más fácil y rápido.
Limita los efectos en cambios.
Cuando se realiza un cambio en alguna clase, el funcionamiento afectado solo será a
la clase y a las dependencias de esa clase en específico, por lo cual no obliga a
modificar todo el código, solo algunas partes para que la modificación surja efecto.
31
Oculta información global.
Si se necesita utilizar datos a nivel global, se puede ocultar los detalles de la
implementación dentro de una clase. Trabajar con datos globales a través de rutinas
de acceso hacen mucho más fácil la interacción con los datos. Esto permite el poder
cambiar la estructura de datos sin cambiar el programa. Con ello también se puede
monitorear el acceso a datos.
Así como existen razones para crear clases, existen razones por la cual no crear este
tipo de clases como:
Clases omnipotentes.
Si una clase consume tiempo en llamar otras funciones y atributos de otras clases
para utilizarlos, es mejor considerar hacer esas mismas funciones dentro las clases a
utilizar en la clase omnipotente.
Clases irrelevantes.
Si una clase solo consiste de puros datos, mejor considera utilizar esos datos en
otras clases o reconsidera si es en realidad una clase. En caso de que solo cuente
con métodos, es mejor en caso de unos lenguajes, transfórmalo en una interfaz o en
otro caso pasar esas funcionalidades en otras clases que puedan utilizarlas.
32
Razones por la cual crear una rutina.
Las razones válidas para la cual crear una rutina se listan a continuación:
Reducen la complejidad.
La razón más importante por la cual crear una rutina es para reducir la complejidad
de un programa. La rutina una vez creada, pueden pasar un largo tiempo cuando se
requiera utilizar, pero ya no será necesario conocer que es lo que hace internamente,
ya que solo se utilizara para obtener o realizar las acciones requeridas.
Introduce una abstracción intermedia comprensible.
El poner instrucciones dentro de una rutina con buen nombre es una buena forma de
documentar su propósito. Por ejemplo, cuánto cuesta determinado producto con una
línea de código como la siguiente:
Var productPrice = product.GetProductPrice(productID);
Evita código duplicado.
La razón más conocida como se menciona con anterioridad, las rutinas se crean para
evitar repetir código. Si existen dos funciones que tienen que repetir varias
sentencias de código, existe un error en la descomposición. Una forma de corregir
esto es poner el código repetido dentro de una clase base y después mover las dos
rutinas especializadas dentro de subclases. O solamente crear una rutina que
contenga el código repetido y llamarla dentro de cada rutina especializada.
Cualquiera de los dos casos ayudara a no repetir código. Con esto el código se
vuelve más legible. Porque con esto solamente se tiene que verificar en un solo lugar
si el código está correcto.
33
Oculta secuencias.
Por ejemplo, si dos funciones necesitan ser ejecutadas primero antes de poder iniciar
sesión dentro de una aplicación, es mejor tener una función que las ejecute y permita
ingresar dentro de la aplicación regresando una respuesta.
Mejora la portabilidad.
Más que nada se refiere al poder utilizar las rutinas con facilidad en otras clases o
dentro de la misma clase.
Mejora el rendimiento.
La manera de optimizar el código primeramente es tener el código en un solo lugar
para poder encontrar las ineficiencias. El centralizar el código dentro de una rutina,
significa que, si esta es mejorada, todo código que utilice esa rutina será mejorado
también, aunque sea de manera directa o indirecta.
34
Como nombrar a una rutina.
Se dice que una rutina cuenta con un buen nombre cuando, con el solo hecho de leer
su nombre se sabe el objetivo que cumple la rutina por dentro sin la necesidad de
leer el código. Algunas recomendaciones para nombrar rutinas son:
Describir lo que la rutina hace.
Cuando se nombra una rutina, es recomendable describir todos los paramentos de
salida y sus procesos. Por ejemplo, si se cuenta con una rutina que calcula los
totales, los presenta en un reporte y después abre el reporte obtenido, el nombre
para la rutina “CalcularReportesTotales” no sería un nombre adecuado para el
reporte. El nombre “CalculaReportesTotalesYAbreElReporte” podría ser adecuado,
pero el nombre es muy largo y absurdo. Para este caso, sería una buena opción
nómbralo “ObtenerTotalesEnReporte”.
Evitar verbos que carezcan de significado.
Si alguna vez se llega a programar en inglés, programadores de la lengua inglesa
recomiendan no utilizar verbos sin especificar como se está utilizando. Por ejemplo,
rutinas nombradas como HandleCalculation(), OutputUser(), ProcessInput() o
DealWithOutput() no dicen ciertamente que es lo que hacen. A lo mucho, dicen
cuáles son los procesos con las que están relacionadas mas no que parte está
solucionando.
Hacer los nombres de las rutinas tan grandes como sea necesario.
Varias investigaciones mencionan que el promedio óptimo para nombrar a una
variable es de 9 a 15 caracteres. Las rutinas tienden a ser más complicadas que las
variables, y los nombres largos tienden a ser buenos.
Para nombrar una función, usa una descripción del valor de retorno.
Una función debe de ser nombrada en base al tipo de valor que regresa.
35
Para nombrar un procedimiento, utilizar un buen verbo seguido de un objeto.
Un procedimiento con cohesión funcional usualmente desempeña una operación
sobre un objeto. El nombre deberá reflejar que hace el procedimiento, y la operación
en el objeto implica un verbo más el nombre del objeto.
Utilizar antónimos precisos.
Utilizar reglas de nombramiento para funciones opuestas, estas ayudan a la
consistencia. Antónimos como primero/ultimo son más fáciles de comprender.
Establecer reglas para operaciones comunes.
En muchos sistemas, es importante distinguir entre diferentes tipos de operaciones.
Un reglamento de nombramiento es comúnmente de manera más fácil y fiable para
indicar estas distinciones.
36
JavaScript
JavaScript es un lenguaje multiplataforma y orientado a objetos. Su núcleo contiene
un conjunto de objetos, como son Arreglos, Fechas y Matemáticas. También
elementos del lenguaje como son operadores, estructuras de control y argumentos.
[31] Es un lenguaje interpretado orientado a las páginas web, con una sintaxis
semejante a la del lenguaje Java.
El lenguaje fue inventado por Brendan Eich [32] en la empresa
Netscape Communications, que es la que fabricó los primeros navegadores de
Internet comerciales. Apareció por primera vez en el producto de Netscape llamado
Netscape Navigator 2.0.
Se utiliza en páginas web HTML, para realizar tareas y operaciones en
el marco de la aplicación cliente. Los autores inicialmente lo llamaron Mocha y más
tarde LiveScript pero fue rebautizado como JavaScript en un anuncio conjunto entre
Sun Microsystems y Netscape, el 4 de diciembre de 1995 [33].
37
CSS
CSS, siglas en ingles de Cascading StyleSheets (Hojas de Estilo en Cascada), es un
lenguaje que describe la presentación de los documentos estructurados en hojas de
estilo para diferentes métodos de interpretación, es decir, define cómo se va a
mostrar un documento en pantalla [34].
El lenguaje CSS se basa en una serie de reglas que rigen el estilo de
los elementos en los documentos estructurados, y que forman la sintaxis de las hojas
de estilo. Cada regla consiste en un selector y una declaración, esta última va entre
corchetes y consiste en una propiedad o atributo, y un valor separados por dos
puntos.
38
Control de versiones
Se define como control de versiones a la gestión de los diversos cambios que se
realizan sobre los elementos de algún producto o una configuración del mismo. Una
versión, revisión o edición de un producto, es el estado en el que se encuentra el
mismo en un momento dado de su desarrollo o modificación [35].
Aunque un sistema de control de versiones puede realizarse de forma
manual, es muy aconsejable disponer de herramientas que faciliten esta gestión
dando lugar a los llamados sistemas de control de versiones o VCS (del inglés
Version Control System). Estos sistemas facilitan la administración de las distintas
versiones de cada producto desarrollado, así como las posibles especializaciones
realizadas.
El control de versiones se realiza principalmente en la industria
informática para controlar las distintas versiones del código fuente dando lugar a los
sistemas de control de código fuente o SCM (siglas del inglés Source Code
Management).
39
MSSQL
Microsoft SQL Server es un sistema de manejo de bases de datos del modelo
relacional (RDBMS por sus siglas en inglés), que soporta una gran variedad de
procesos de transacciones, inteligencia de negocios y análisis de aplicaciones en
ambiente IT corporativos. Es uno de los tres líderes en el mercado como tecnología
en bases de datos (Junto a Oracle y MySQL).
Como otros software RDBMS, MSSQL está construido en base de SQL,
que es un lenguaje estandarizado de programación que los administradores de base
de datos (DBAs) y otros profesionales en las tecnologías de la información usan para
manejar bases de datos y consultar la información que contienen. SQL Server
contiene SQL de transacciones, una implementación a SQL de Microsoft que añade
una serie de propiedades que son extensiones de programación para el lenguaje
estándar.
El código original de SQL Server fue desarrollado en los 80s por el
creador Sybase Inc., que actualmente se conoce que fue adquirido por SAP
(empresa de software). Inicialmente, Sybase construyo el programa para correr en
sistemas UNIX y plataformas de minicomputadoras. Después Microsoft y Ashton-
Tate Corp., se unieron con Sybase para producir la primera versión que se
convertiría en Microsoft SQL Server, diseñado para sistemas operativos OS/2 y
lanzado en 1989.
Como otras tecnologías RDBMS, SQL Server fue construido
principalmente en una estructura basada en filas de tablas que conectan información
relacionada con otras tablas, evitando la necesidad de guardar la misma información
en múltiples lugares dentro de la base de datos. El modelo relacional también provee
integridad referencial y otros tipos de integridad para mantener la integridad de los
datos. Esos puntos son en base a las propiedades de ACID con el objetivo de
garantizar que las transacciones dentro de la base de datos sean confiables.
ACID (acrónimo de Atomicidad, Consistencia, Aislamiento y
Durabilidad), son propiedades que garantizan que una transacción sea confiable [36].
40
El núcleo de MSSQL es el motor de base de datos con el que cuenta,
conocido como SQL Server Database Engine, que controla el guardado de datos,
procesamiento y seguridad. Este incluye un motor relacional que procesa los
comandos y las consultas. También cuenta con un motor de almacenamiento que
maneja los archivos de base de datos, tablas, paginas, indexes, búfer de datos y
transacciones. Los procedimientos almacenados, disparadores, vistas y otros objetos
son también creados y ejecutados por el motor de base de datos [37].
A continuación, se muestra una lista de ventajas y desventajas de MSSQL [38].
Ventajas:
Soporte de transacciones
Escalabilidad, estabilidad y seguridad.
Soporta procedimientos almacenados.
Incluye también un potente entorno gráfico de administración, que permite el
uso de comandos DDL y DML gráficamente.
Permite trabajar en modo cliente-servidor, donde la información y datos se
alojan en el servidor y las terminales o clientes de la red sólo acceden a la
información.
Permite administrar información de otros servidores de datos.
Desventajas:
Costo de las licencias comparadas con otros competidores
41
Infraestructura .Net
.NET Framework es una tecnología que soporta la compilación y ejecución de
aplicaciones y servicios Web XML de última generación. El diseño de .NET
Framework está enfocado a cumplir los siguientes objetivos:
Proporcionar un entorno coherente de programación orientada a objetos, en el
que, el código de los objetos se pueda almacenar y ejecutar de forma local,
pero distribuida en Internet o ejecutar de forma remota.
Proporcionar un entorno de ejecución de código que minimiza los conflictos en
el despliegue y versionado de software.
Ofrecer un entorno de ejecución de código que promueva la ejecución segura
del mismo, incluso del creado por terceros desconocidos o que no son de
plena confianza.
Proporcionar un entorno de ejecución de código que elimine los problemas de
rendimiento de los entornos en los que se utilizan scripts o intérpretes de
comandos.
Ofrecer al programador una experiencia coherente entre tipos de aplicaciones
muy diferentes, como las basadas en Windows o en el Web.
Basar toda la comunicación en estándares del sector para asegurar que el
código de .NET Framework se puede integrar con otros tipos de código.
.NET Framework consta de dos componentes principales: Common
Language Runtime y la biblioteca de clases de .NET Framework. Common Language
Runtime es el fundamento de .NET Framework. La biblioteca de clases es una
completa colección orientada a objetos de tipos reutilizables que se pueden emplear
para desarrollar aplicaciones que abarcan desde las tradicionales herramientas de
interfaz gráfica de usuario (GUI) o de línea de comandos hasta las aplicaciones
basadas en las innovaciones más recientes proporcionadas por ASP.NET, como
Web Forms y Servicios Web XML.
42
.NET Framework puede hospedarse en componentes no administrados
que cargan Common Language Runtime en sus procesos e inician la ejecución de
código administrado, con lo que se crea un entorno de software en el que se pueden
utilizar características administradas y no administradas. En .NET Framework no sólo
se ofrecen varios hosts de motor en tiempo de ejecución, sino que también se admite
el desarrollo de estos hosts por parte de terceros.
Por ejemplo, ASP.NET hospeda el motor en tiempo de ejecución para
proporcionar un entorno de servidor escalable para el código administrado. ASP.NET
trabaja directamente con el motor en tiempo de ejecución para habilitar aplicaciones
de ASP.NET y servicios Web XML, que se tratan más adelante en este tema.
Internet Explorer es un ejemplo de aplicación no administrada que
hospeda el motor en tiempo de ejecución (en forma de una extensión de tipo MIME).
Al usar Internet Explorer para hospedar el motor en tiempo de ejecución, puede
incrustar componentes administrados o controles de Windows Forms en documentos
HTML. Al hospedar el runtime se hace posible el uso de código móvil administrado,
pero con mejoras significativas que solo el código administrado puede ofrecer, como
la ejecución con confianza parcial y el almacenamiento aislado de archivos.
43
En la Figura 2, se muestra la relación de Common Language Runtime y
la biblioteca de clases con las aplicaciones y el sistema en su conjunto. En la misma
se representa cómo funciona el código administrado dentro de una arquitectura
mayor.
Fuente: https://msdn.microsoft.com/es-mx/library/zw4w595w(v=vs.110).aspx
Figura 2. CLR en conjunto con otras tecnologías de Microsoft.
44
Infraestructura .Net Core
.NET Core es una versión modular de .NET Framework diseñada para que sea
portátil entre plataformas, a fin de permitir la reutilización del código al máximo y su
uso compartido. Además, .NET Core es de código abierto y aceptará las
contribuciones de la comunidad [39].
.NET Core es portátil entre plataformas porque, aunque se trata de un
subconjunto de la versión completa de .NET Framework, proporciona una
funcionalidad clave para implementar las características de la aplicación que necesita
y reutilizar este código independientemente del destino de la plataforma. Antes, las
distintas versiones de .NET para diferentes plataformas carecían de funcionalidad
compartida para las tareas clave, como la lectura de archivos locales. Las
plataformas de Microsoft que podrá establecer como destino con .NET Core incluyen
Windows de escritorio tradicional, así como dispositivos y teléfonos de Windows.
Cuando se usan herramientas de terceros como Xamarin, .NET Core debe ser
portátil para dispositivos IOS y Android. Además, .NET Core está disponible para los
sistemas operativos Mac y Linux para permitir que las aplicaciones web se ejecuten
en estos sistemas.
.NET Core es modular, ya que se publica a través de NuGet en
paquetes de ensamblado más reducidos. En lugar de un ensamblado grande que
contiene la mayor parte de la funcionalidad básica, .NET Core está disponible como
paquetes más pequeños centrados en las características. Esto permite un modelo de
desarrollo más ágil y ofrece la posibilidad de elegir las funcionalidades que necesita
para sus aplicaciones y bibliotecas.
45
C#
C# es un lenguaje elegante, con seguridad de tipos y orientado a objetos, que
permite a los desarrolladores crear una gran variedad de aplicaciones seguras y
sólidas que se ejecutan en .NET Framework .NET. Puede usar C# para crear
aplicaciones cliente de Windows, servicios web XML, componentes distribuidos,
aplicaciones cliente-servidor, aplicaciones de base de datos, etcétera. Visual C#
proporciona un editor de código avanzado, prácticos diseñadores de interfaz de
usuario, un depurador integrado y otras herramientas que facilitan el desarrollo de
aplicaciones basadas en el lenguaje C# y .NET Framework [40].
Durante el desarrollo de la plataforma .NET, las bibliotecas de clases
fueron escritas originalmente usando un sistema de código gestionado llamado
Simple Managed C (SMC). En enero de 1999, Anders Hejlsberg formó un equipo con
la misión de desarrollar un nuevo lenguaje de programación llamado Cool (Lenguaje
C orientado a objetos). Este nombre tuvo que ser cambiado debido a problemas de
marca, pasando a llamarse C# [41].
En cuanto lenguaje orientado a objetos, C# admite los conceptos de
encapsulación, herencia y polimorfismo. Todas las variables y métodos, incluido el
método Main, el punto de entrada de la aplicación, se encapsulan dentro de las
definiciones de clase. Una clase puede heredar directamente de una clase primaria,
pero puede implementar cualquier número de interfaces. Los métodos que invalidan
los métodos virtuales en una clase primaria requieren la palabra clave override como
una manera de evitar redefiniciones accidentales. En C#, un struct es como una
clase sencilla; es un tipo asignado en la pila que puede implementar interfaces pero
que no admite herencia.
46
Además de estos principios básicos orientados a objetos, C# facilita el
desarrollo de componentes de software mediante varias construcciones de lenguaje
innovadoras, incluidas las siguientes:
Signaturas de método encapsulado llamadas delegados, que permiten
notificaciones de eventos con seguridad de tipos.
Propiedades, que actúan como descriptores de acceso para variables
miembro privadas.
Atributos, que proporcionan metadatos declarativos sobre tipos en tiempo de
ejecución.
Comentarios de documentación XML insertados
Language-Integrated Query (LINQ) que proporciona funcionalidades de
consulta integradas en diversos orígenes de datos.
47
ASP.NET MVC
El modelo arquitectónico Modelo-Vista-Controlador (MVC) separa una aplicación en
tres componentes principales: el modelo, la vista y el controlador. El marco de
ASP.NET MVC proporciona una alternativa al modelo de formularios Web Forms de
ASP.NET para crear aplicaciones web. El marco de ASP.NET MVC es un marco de
presentación de poca complejidad y fácil de comprobar que (como las aplicaciones
basadas en formularios Web Forms) se integra con las características de ASP.NET
existentes, tales como páginas maestras y la autenticación basada en pertenencia. El
marco de MVC se define en el ensamblado System.Web.Mvc.
Ventajas de una aplicación web basada en MVC
El marco de ASP.NET MVC ofrece las ventajas siguientes:
Facilita la administración de la complejidad, al dividir una aplicación en el
modelo, la vista y el controlador.
No usa el estado de vista ni formularios basados en servidor. Esto hace que el
marco de MVC sea ideal para los desarrolladores que deseen un control
completo sobre el comportamiento de una aplicación.
Usa un modelo de controlador frontal que procesa las solicitudes de la
aplicación web a través de un controlador único. Esto permite diseñar una
aplicación que admite una infraestructura de enrutamiento avanzada.
Proporciona una mayor compatibilidad con el desarrollo basado en pruebas
(TDD).
Funciona bien para las aplicaciones web en las que trabajan equipos grandes
de desarrolladores y para los diseñadores web que necesitan un alto grado de
control sobre el comportamiento de la aplicación.
48
Ventajas de una aplicación web basada en formularios Web Forms
El marco basado en formularios Web Forms ofrece las ventajas siguientes:
Admite un modelo de eventos que conserva el estado sobre HTTP, lo cual
favorece al desarrollo de la aplicación web de línea de negocio. La aplicación
basada en formularios Web Forms proporciona docenas de eventos que se
admiten en centenares de controles de servidor.
Usa un modelo de controlador de página que agrega funcionalidad a las
páginas individuales.
Usa el estado de vista de los formularios basados en servidor, lo cual puede
facilitar la administración de la información de estado.
Funciona bien para los equipos pequeños de desarrolladores web y los
diseñadores que deseen aprovechar el gran número de componentes
disponible para el desarrollo rápido de aplicaciones.
En general, es menos complejo para el desarrollo de aplicaciones, puesto que
los componentes se integran estrechamente y suelen requerir menos código
que el modelo MVC.
49
Entity Framework
Entity Framework es un conjunto de tecnologías de ADO.NET que permiten el
desarrollo de aplicaciones de software orientadas a datos [42].
Entity Framework permite a los desarrolladores trabajar con datos en
forma de objetos y propiedades específicos del dominio, como clientes y direcciones
de cliente, sin tener que preocuparse por las tablas y columnas de la base de datos
subyacente donde se almacenan estos datos. Con Entity Framework, los
desarrolladores pueden trabajar en un nivel mayor de abstracción cuando tratan con
datos, y pueden crear y mantener aplicaciones orientadas a datos con menos código
que en las aplicaciones tradicionales. Dado que Entity Framework es un componente
de .NET Framework, las aplicaciones de Entity Framework se pueden ejecutar en
cualquier equipo en el que esté instalado .NET Framework a partir de la versión 3.5
SP1.
Como algo más que otra solución de asignación objeto-relacional, Entity
Framework trata fundamentalmente de permitir que las aplicaciones obtengan
acceso y cambien los datos que están representados como entidades y relaciones en
el modelo conceptual. Usa la información de los archivos del modelo y de asignación
para traducir las consultas de un objeto con los tipos de entidad que se representan
en el modelo conceptual en consultas específicas del origen de datos. Los resultados
de la consulta se materializan en objetos administrables para la infraestructura.
Entity Framework incluye el proveedor de datos de EntityClient. Este
proveedor administra las conexiones, traduce las consultas de entidad en consultas
específicas del origen de datos y devuelve un lector de datos que Entity Framework
usa para materializar los datos de la entidad en los objetos.
50
A continuación, en la Figura 3 se muestra un diagrama representando la
arquitectura de Entity Framework para el acceso a datos:
Figura 3. Funcionalidad interna de Entity Framework para el acceso a datos.
Fuente: https://msdn.microsoft.com/es-es/library/bb399567(v=vs.110).aspx
51
Sumario
En base a la información recolectada, el uso de buenas prácticas en el desarrollo de
software es algo primordial para el éxito en este tipo de proyectos, ya que ayudan a
agilizar las diferentes tareas que se realizan, con el objetivo de mejorar el producto
final sin requerir de un esfuerzo excesivo y un gasto grande de recursos.
El uso de aplicaciones de Microsoft ayuda mucho a aplicar estas
buenas prácticas. Ya que con Entity Framework ayuda de manera considerable al
acceso a datos.
También cuentan con uno de los sistemas gestores de bases de datos
relacionales más famosos en el mercado, lo cual ayuda a los tiempos de respuesta
de una aplicación en cuestiones de inserción y lectura de datos. Más aún que ofrece
un fuerte manejador de transacciones para que la información se encuentre segura
dentro de esos procesos.
Sin dejar de lado C#, que han seguido mejorando para ser un lenguaje
con muchas facilidades para los programadores y abarcar muchos ámbitos para la
obtención y manipulación de información para poder presentarse al usuario final.
Este cuenta con un manejo de hilos muy fuerte ya conocido como Tarea y no como
hilo, ya que se ejecuta de manera más segura y confiable la tarea a asignar.
CAPÍTULO 3
METODOLOGIA
53
En este capítulo se mencionará las herramientas que me permitirán utilizar las
tecnologías mencionadas en el capítulo anterior, junto a las técnicas descritas. Para
esto se harán demostraciones con el lenguaje mencionado con anterioridad, C# en
conjunto con otras tecnologías. A excepción de utilizar las librerías de .Net
Framework debido a su menor complejidad que .Net Core.
54
Herramientas
En este apartado se mencionan las herramientas más comunes de desarrollo de
aplicaciones web con ASP.NET Framework.
IDE (Integrated Development Enviroment)
El IDE Visual Studio es un conjunto completo de herramientas de desarrollo para la
generación de aplicaciones web ASP.NET, Servicios Web XML, aplicaciones de
escritorio y aplicaciones móviles. Visual Basic, Visual C# y Visual C++ utilizan todos
los mismos entornos de desarrollo integrado (IDE), que habilita el uso compartido de
herramientas y facilita la creación de soluciones en varios lenguajes. Asimismo,
dichos lenguajes utilizan las funciones de .NET Framework, las cuales ofrecen
acceso a tecnologías clave para simplificar el desarrollo de aplicaciones web ASP y
Servicios Web XML.
Figura 4. Logotipo de Visual Studio.
Fuente: https://commons.wikimedia.org/wiki/File:Visual_Studio_2012_logo_and_wordmark.svg
55
jQuery
Es biblioteca multiplataforma de JavaScript, creada inicialmente por John Resig, que
permite simplificar la manera de interactuar con los documentos HTML, manipular el
árbol DOM, manejar eventos, desarrollar animaciones y agregar interacción con la
técnica AJAX a páginas web. Fue presentada el 14 de enero de 2006 en el BarCamp
NYC. jQuery es la biblioteca de JavaScript más utilizada [43].
jQuery es software libre y de código abierto, posee un doble
licenciamiento bajo la Licencia MIT y la Licencia Pública General de GNU v2,
permitiendo su uso en proyectos libres y privados [44]. jQuery, al igual que otras
bibliotecas, ofrece una serie de funcionalidades basadas en JavaScript que de otra
manera requerirían de mucho más código, es decir, con las funciones propias de
esta biblioteca se logran grandes resultados en menos tiempo y espacio.
La característica principal de la biblioteca es que permite cambiar el
contenido de una página web sin necesidad de recargarla, mediante la manipulación
del árbol DOM y peticiones AJAX [45].
Figura 5. Logotipo de jQuery.
Fuente: http://jquery.com/
56
Las ventajas y desventajas de jQuery se muestran en la Tabla 3:
Ventajas Desventajas
jQuery es flexible y rápido para el
desarrollo web
Viene con licencia MIT y es Open
Source
Tiene una excelente comunidad de
soporte
Tiene Plugins
Bugs son resueltos rápidamente
Excelente integración con AJAX
jQuery es fácil de instalar y
aprender, inicialmente. Pero no es
tan fácil si lo comparamos con
CSS.
Si jQuery es implementado
inapropiadamente como un
Framework, el entorno de
desarrollo se puede salir de
control.
Tabla 3. Ventajas y desventajas de la librería jQuery.
Fuente: http://blog.capacityacademy.com/2013/03/16/jquery-que-es-origenes-ventajas-desventajas/
57
Bootstrap
Framework originalmente creado por Twitter, que permite crear interfaces web con
CSS y JavaScript, cuya particularidad es la de adaptar la interfaz del sitio web al
tamaño del dispositivo en que se visualice. Es decir, el sitio web se adapta
automáticamente al tamaño de una PC, una Tablet u otro dispositivo. Esta técnica de
diseño y desarrollo se conoce como Responsive Design o Diseño Adaptativo.
Algunas características principales de Bootstrap son [46]:
Permite crear interfaces que se adapten a los diferentes navegadores, tanto de
escritorio como tabletas y móviles a distintas escalas y resoluciones.
Se integra perfectamente con las principales librerías Javascript, por ejemplo,
JQuery.
Ofrece un diseño sólido usando LESS y estándares como CSS3/HTML5.
Es un framework ligero que se integra de forma limpia en nuestro proyecto
actual.
Figura 6. Logotipo de Bootstrap.
Fuente: https://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Boostrap_logo.svg/220px-
Boostrap_logo.svg.png
58
Funciona con todos los navegadores, incluido Internet Explorer
usando HTMLShim para que reconozca las etiquetas HTML5.
Dispone de distintos layout predefinidos con estructuras fijas a 940 píxeles de
distintas columnas o diseños fluidos.
Las ventajas y desventajas de Bootstrap se listan en la siguiente tabla:
Ventajas Desventajas
Cuenta con un mantenimiento y
actualización realizados por
Twitter: esto no quiere decir que
esta herramienta sea perfecta,
pero gran parte del trabajo interno
ya está llevado a cabo por sus
creadores.
Ofrece un paquete de elementos
web personalizables: con
Bootstrap puedes diseñar una web
jugando con sus elementos
compuestos por diferentes
combinaciones de HTML, CSS y
Javascript, de manera que las
piezas siempre encajan.
Es una herramienta de uso ágil y
sencillo: facilita enormemente el
diseño de interfaces y además
incluye por defecto una plantilla
bastante optimizada.
Se convierte en una tarea
complicada cambiar de versión si
has realizado modificaciones
profundas sobre el núcleo.
Si necesitas añadir componentes
que no existen, debes hacerlos tú
mismo en CSS y cuidar de que
mantenga coherencia con tu
diseño y mantener su
responsividad.
Tabla 4. Ventajas y desventajas del Framework Bootstrap
Fuente:http://tecnologiaenvivo.com/bootstrap-ventajas-y-desventajas/
59
SSMS
SQL Server Management Studio es un ambiente integrado para el manejo de
cualquier infraestructura SQL [47]. Es utilizado para acceder, configurar, administrar
y desarrollar todos los componentes de SQL Server, Azure SQL Database y SQL
Data Warehouse. SSMS provee una sola utilidad comprensiva, que combina un
grupo de herramientas graficas con un buen número de editores de código para
proveer el acceso a servidores SQL para desarrolladores y administradores de base
de datos de todos los niveles.
Los componentes SQL Server Management Studio son:
1.- Explorador de objetos: Utilizado para manejar y apreciar todos los objetos en
una o varias instancias de servidores de SQL.
2.- Explorador de plantillas: Ayuda a visualizar códigos para el apoyo de creación
de base de datos, conexiones y relaciones.
3.- Explorador de soluciones: Provee contenedores llamados proyectos para
manejar objetos como scripts de base de datos, consultas, conexiones a datos y
archivos.
Figura 7. Logotipo de SSMS.
Fuente: https://seniordba.wordpress.com/2017/06/19/free-download-sql-server-management-
studio-17/
60
Git
Git es sistema de control de versiones distribuido de manera gratuito y de código
abierto diseñado para manejar todo desde proyectos pequeños hasta muy grandes
con rapidez y eficiencia. Diseñado por Linus Torvalds, pensando en la eficiencia y la
confiabilidad del mantenimiento de versiones de aplicaciones cuando éstas tienen un
gran número de archivos de código fuente. Al principio, Git se pensó como un motor
de bajo nivel sobre el cual otros pudieran escribir la interfaz de usuario o front end
como Cogito o StGIT [48].
La característica principal que hace a Git estar aparte de otros sistemas
de control de versiones es su modelo de ramas. Git permite y motiva a tener varias
ramas locales que pueden ser totalmente independientes entre sí. La creación, la
mezcla y la eliminación de esas ramas toman segundos.
Entre las características más relevantes se encuentran [49]:
Los almacenes de información pueden publicarse por HTTP, FTP, rsync o
mediante un protocolo nativo, ya sea a través de una conexión TCP/IP simple
o a través de cifrado SSH. Git también puede emular servidores CVS, lo que
habilita el uso de clientes CVS pre-existentes y módulos IDE para CVS pre-
existentes en el acceso de repositorios Git.
Los repositorios Subversion y svk se pueden usar directamente con git-svn.
Gestión eficiente de proyectos grandes, dada la rapidez de gestión de
diferencias entre archivos, entre otras mejoras de optimización de velocidad
de ejecución.
Figura 8. Logotipo de Git.
Fuente: https://git-scm.com/images/logos/downloads/Git-Logo-2Color.png
61
Resulta algo más caro trabajar con ficheros concretos frente a proyectos, eso
diferencia el trabajo frente a CVS, que trabaja con base en cambios de fichero,
pero mejora el trabajo con afectaciones de código que concurren en
operaciones similares en varios archivos.
Re-almacenamiento periódico en paquetes (ficheros). Esto es relativamente
eficiente para escritura de cambios y relativamente ineficiente para lectura si el
reempaquetado (con base en diferencias) no ocurre cada cierto tiempo.
62
Procedimiento
En esta sección se describe la forma de utilizar las herramientas mencionadas
anteriormente para la creación de páginas web.
Introducción a ASP.NET MVC con Entity Framework.
Durante las estadías, se utilizó la tecnología de Microsoft para la creación de páginas
web ASP.NET MVC con Entity Framework. Para manejar este tipo de proyectos, se
utiliza el IDE proveído por Microsoft de manera gratuita Visual Studio 2017
Community, desde su página oficial [50]. Se ejecuta el instalador y se descargan
todos los componentes.
Una vez instalado con todos los componentes, se genera un nuevo
proyecto, como se muestra en la figura 9.
Una vez dentro, pedirá que tipo de proyecto se desea construir, en este
caso será un proyecto de Visual C# Web – Aplicación Web ASP.NET (.Net
Framework) utilizando el Framework 4.5.2 como se muestra en la Figura 10.
También se agregará al control de versiones.
Figura 9. Creación de un nuevo proyecto.
63
Una vez elegido el proyecto a realizar, se establece la plantilla a utilizar,
las carpetas y referencias a utilizar, así como el tipo de autenticación que se utilizara
para el acceso a las partes restringidas del sistema, ejemplificado en la Figura 11.
Una vez todo establecido, se acepta la configuración y el IDE generara
la estructura del proyecto, apareciendo una ventana como se muestra en la Figura
12.
Figura 11. Establecimiento de la estructura del proyecto.
Figura 12. Generación de la estructura del proyecto.
Figura 10. Selección del tipo de proyecto a crear.
64
Una vez generado el proyecto, cargara una página de inicio y la
estructura del proyecto como se muestra en la figura 13.
Se utilizará el procedimiento de Code First Migrations, donde este
procedimiento se basa en generar las tablas de una base de datos tomando como
referencia, los modelos utilizados para el control de información dentro de la
aplicación. Para ello, primero en la carpeta de modelos se abren sus opciones y se
selecciona Agregar > Clase (Figura 14).
Figura 13. Estructura del proyecto generada.
Figura 14. Creación de un modelo en ASP.NET (Paso 1).
65
Una vez en esta ventana, se asigna el nombre de la clase a crear, en el
campo que se muestra en la Figura 15.
Una vez generada la nueva clase, se generará una estructura como se
muestra en la Figura 16:
En ella se puede apreciar los namespaces a utilizar y a cuál estará
asignada la clase. Estos son utilizados para declarar el alcance que tiene un conjunto
de objetos relacionados. Aparte del nombre de la clase y su nivel de acceso [51].
Figura 15. Creación de un modelo en ASP.NET (Paso 2).
Figura 16. Creación de un modelo en ASP.NET (Paso 3).
66
Ilustrado en la Figura 17, en la clase se agregarán todos los campos
con los cuales contara el modelo que se reflejarán como campos dentro de la base
de datos.
Una vez agregados todos los campos al modelo, se crea una migración.
Las migraciones son clases dentro de nuestro software con la capacidad de
manipular los metadatos de la base de datos a utilizar, con el objetivo de hacer una
estructura conforme la aplicación crece.
Para crear una migración, primero se tiene que activar la ventana para
la consola del administrador de paquetes, que se encuentra en Ver > Otras ventanas,
mostrado en la Figura 18.
Figura 17. Asignación de atributos a un modelo.
Figura 18. Abrir la línea de comandos del administrador de paquetes.
67
Para poder utilizar migraciones en un proyecto, a veces es requerido
activarlas, para poder hacer eso, se ejecuta el comando Enable-Migrations, utilizado
en la Figura 19.
Una vez habilitadas las migraciones, se ejecuta el comando add-
migration “Nombre de la migración” como se muestra en la siguiente figura:
Una vez terminada la ejecución de la migración, aparecerá de manera
automática en una nueva pestaña el código generado por el scaffolding (Figura 21 y
22). A simple vista se puede apreciar que es una clase que hereda de DbMigrations.
En la migración, la primera función es Up(), la cual será encargada de construir el
diseño de las tablas dentro de la base de datos.
Figura 19. Habilitar migraciones en el proyecto.
Figura 20. Creación de una migración en ASP.NET.
68
Dentro de esta misma función (Figura 21), se pueden determinar las
relaciones que existen entre tablas por medio de llaves foráneas y si estas afectaran
a las otras tablas por medio de la eliminación en cascada.
Por otro lado, se encuentra la función Down() en la Figura 22, la cual se
encarga de destruir los cambios que la migración tiene para realizar en la función
Up().
Figura 21. Estructura de una migración (Función Up).
Figura 22. Estructura de una migración (Función Down).
69
Una vez creada la migración, se tiene que definir en el contexto de
Entity Framework, con el objetivo de que este reconozca la tabla dentro de su motor
y pueda ser utilizada dentro de la aplicación. Para ello ya existe una clase con el
nombre ApplicationDbContext que se encuentra en el archivo que se encuentra en
Models/IdentityModels. Mostrando su ubicación y código en la Figura 23.
En ella, se crea una variable DbSet del tipo Gig, para poder manipular
la tabla (Figura 24).
Figura 23. Clase ApplicationDbContext en la estructura de la aplicación.
Figura 24. Creacion del DbSet para el modelo en ApplicationDbContext.
70
Una vez agregada al contexto, se puede crear la base de datos, pero
antes, se modifica el archivo de configuración de la aplicación, el cual es Web.config
que se encuentra en la raíz de la aplicación. Una vez dentro del archivo, se puede
apreciar que es un archivo XML con la configuración global de la aplicación, dentro
de él, existe una etiqueta que se llama connectionStrings la cual contiene todas las
cadenas de conexiones que existen para la base o bases de datos. En este caso,
solo se maneja una. Dentro de la cadena de conexión se puede apreciar dos veces
el mismo nombre de la base de datos, en un campo llamando Catalog y otro llamado
DataSource, este es el nombre que recibirá la base de datos, si se desea modificar
se puede hacer con toda la libertad, ya que el generador de código automático,
genera el nombre de la base de datos de la siguiente manera: aspnet- ‘Nombre de la
aplicación’- ‘Fecha y hora de creación del proyecto’, mostrado en la Figura 25.
Una vez observado y realizado los pasos anteriores, se puede crear la
base de datos con el comando update-database dentro de la consola del
administrador de paquetes, como se ilustra en la figura 26.
Figura 25. Configuración de la cadena de conexión a BD en el archivo web.config.
Figura 26. Ejecución de las migraciones para estructurar la base de datos.
71
Una vez ejecutado el comando, todo debe de salir con éxito ya que es
la primera migración, y no se realizó ningún cambio que afectara otras tablas. Para
comprobar si la base de datos se creó correctamente, se ocupa activar la ventana
para ver los objetos SQL, para ello está en la opción Ver > Explorador de objetos de
SQL Server (Figura 27).
Una vez visualizada, aparecerán dos opciones, SQL Server y Proyectos
– GigHub, dentro de SQL Server > (localdb)\MSSQLLocalDB > Bases de datos >
‘Nombre de la BD’, ilustrado en la Figura 28. Debe de aparecer con el nombre
asignado dentro de Web.config.
Una vez creada correctamente la base de datos ya se pueden manejar
la información.
Figura 27. Abrir el explorador de objetos de SQL Server.
Figura 28. Base de datos en el servidor.
72
Obtener información de la base de datos.
Para poder obtener información de la base de datos, se utilizan los controladores, los
cuales permiten el manejo de la información por medio de la aplicación, permitiendo
la comunicación entre los modelos y las vistas. Un ejemplo de una función de un
controlador se muestra en la Figura 29.
Mientras los controladores se encargan de manipular el contenido
mostrado entre las vistas y las peticiones de los usuarios para obtención de la
información, los modelos son los encargados de llevar a cabo la lógica de negocios.
Para la obtención de la información de la base de datos se pueden utilizar también
los controladores, pero no es muy recomendado, ya que estos conforme pasa el
tiempo, se vuelven demasiado grandes y muchas veces hasta se repiten fragmentos
de código que ejecuta exactamente lo mismo. Este tipo de práctica puede ser un
poco “sucia” ya que no optimiza muy bien el trabajo principal del controlador, para
ello, es recomendable utilizar los repositorios. Esto nace con el objetivo de separar
intereses dentro de la aplicación, ya que de esta manera se puede entender mejor el
código.
Figura 29. Controlador utilizado para las secciones genérico en ASP.NET.
73
Un ejemplo de repositorio es ilustrado en la Figura 30:
Dentro de él, se encuentran las funciones para la obtención de la
información dentro de la base de datos, con el objetivo de evitar la duplicación de
código dentro de los controladores, y también de que este pueda ser utilizado
independientemente de que solo un controlador tenga acceso a él. Estas pueden ser
llamadas por uno o varios controladores sin afectar otras implementaciones. También
esto evita que al momento de realizar modificaciones en el código de los repositorios
no afecte a los controladores y puedan seguir trabajando igual como lo hacían
anteriormente.
Para ver un poco con más claridad, la Figura 31 muestra un ejemplo de
cómo se utilizaría la función de un repositorio dentro de un controlador.
Figura 30. Estructura general de un repositorio.
74
Dentro de la función Cancel(), se encuentra la implementación
UnitOfWork, y si, esto implica Dependency Injection, con el cual se puede decir que
esto es lo que ayuda a la implementación de los repositorios. Al leer la función, no
existe la necesidad de tener que acceder a las otras funciones llamadas dentro de
esta para saber lo que está haciendo. El código puede ser leído con facilidad y se
comprende cuál es su objetivo.
Figura 31. Uso de repositorios dentro de un controlador.
75
Uso de anotaciones de datos
Las anotaciones de datos son proveídos por MVC, los cuales ayudan a validar
ciertos campos en cuestiones de guardar o modificar un registro dentro de la base de
datos, más que nada para validar y establecer meta datos dentro de la base de
datos.
En la Figura 32, se puede observar cómo se establecen las anotaciones
dentro de los modelos, con el objetivo de que cumplan los datos los requisitos
necesarios para poder ser utilizados por los modelos.
Las anotaciones de datos utilizadas en este ejemplo son Key, Required,
StringLength y MinLength. La expresión Key permite señalar que, en la base de
datos, ese campo va a ser considerado como la llave primaria. Después tenemos
Required, esta expresión hace que tanto en la base de datos como en la aplicación
los campos siempre contengan un valor que sea válido en base al tipo de dato. Por
último, están StringLenth y MinLength, los cuales se encargan del manejo de
cadenas, uno es para establecer hasta que tamaño puede ser la cadena, y Minlength
sirve para decir que la cadena a guardar debe de ser como mínimo del tamaño de
número de caracteres indicado por esta expresión.
Figura 32. Anotaciones de datos en los atributos de un modelo.
76
Con esto, al dar enviar a un formulario, este recargara la página con los
errores de ingreso de datos al intentar guardar o modificar información dentro de la
aplicación, ejemplo de ello se puede observar en la Figura 33.
Figura 33. Vista validada con las anotaciones de datos.
77
Manejo de vistas
El uso de vistas se maneja con lo que es, HTML5, Bootstrap, jQuery y Razor, estos
permiten crear una página visiblemente estética y con contenido dinámico.
Un ejemplo de código de una vista es la siguiente:
En este fragmento de código se define un formulario, el cual permite
agregar un Gig. Como se puede utilizar un modelo para cargar su información, este
no es cualquier modelo, es una proyección del modelo de Gig, son conocidas como
ViewModels, creado con el objetivo de no cargar con tanto trabajo al modelo,
además, permite la separación de interés dentro de la aplicación. Los ViewModels
permiten cargar toda la información requerida por la vista, para que esta trabaje con
más facilidad, y no tener la necesidad de que, si una vista requiere información de
varios modelos, no tener que requerir a cada uno de los modelos dentro de una vista.
Esto ayuda a simplificar el código de una vista.
Figura 34. Vista utilizando Razor View Engine.
78
Otro punto importante, son las líneas de código con la nomenclatura
@Html.TipodeComponente(Propiedades). Este se encuentra incluido dentro de
Razor View Engine y ayudan a construir el Markup de una aplicación.
Por último, se encuentra la sección de scripts, donde se encarga de
llamar una librería de jQuery validation, con tan solo cargar esta librería, la página
por parte de vistas de usuarios ya está validada.
Un ejemplo que demuestra esto es la ventana ilustrada en la Figura 35,
que al ingresar datos inválidos muestra mensajes de error.
Figura 35. Vista validada con jQuery validator.
79
Respaldo de aplicación en GitHub
Una vez realizados cambios en la aplicación, se generan los respaldos
correspondientes por medio de GitHub, con una extensión para Visual Studio.
Dentro de la aplicación, para ver la ventana del controlador de
versiones, se accede a Ver > Team Explorer, encontrado en la Figura 36.
Una vez visible la ventana, se puede apreciar las diferentes maneras de
poder aplicar control de versiones en nuestra aplicación, en el cual se utilizará
GitHub. Para ello, se requiere una cuenta para GitHub para poder sincronizarse y
subir los proyectos a la cuenta.
Primero, para iniciar sesión se requiere entrar a Team Explorer >
GitHub >Connect, como se ejemplifica en la Figura 37.
Figura 36. Acceso al explorador de equipos.
Figura 37. Conexión a GitHub (Paso 1).
80
Una vez las credenciales insertadas, se inicia sesión (Figura 38).
Una vez conectados, aparecerá la ventana como la Figura 39.
En esta ventana, se permiten ver las acciones que se pueden realizar
en un repositorio. Para poder guardar los cambios en el repositorio, se presiona la
opción “Cambios” y aparecerá una ventana con todos los archivos, creados y
modificados desde la última actualización al respaldo. Para ello requerirá un mensaje
describiendo cuales fueron los cambios significativos que se realizaron en el proyecto
y el motivo de su modificación, como en la Figura 40.
Figura 38. Conexión a GitHub (Paso 2).
Figura 39. Acciones permitidas dentro de un repositorio Git.
81
Una vez escrito el mensaje del motivo de la modificación, se confirman
los cambios e instanciara los archivos de manera local, mostrado en la Figura 41.
Para compartir los cambios en el servidor se tendrán que sincronizar.
Por último, pedirá una confirmación de publicación (Figura 42), para
resolver ese caso, solo se elige la opción insertar.
Figura 40. Guardar los cambios en el repositorio.
Figura 41. Sincronizar los cambios en el repositorio.
82
Una vez publicados los cambios, se recibe un mensaje que se
insertaron los cambios correctamente.
Esto es muy beneficioso, ya que, si se llegase a tener algún problema
con el sistema en desarrollo y se corrompe, que sería el peor de los casos, se
contará con un respaldo en línea donde se podrá descargar de cualquier lugar,
siempre y cuando se cuente con una conexión a Internet.
Figura 42. Publicar los cambios en el repositorio.
CAPÍTULO 4
RESULTADOS
84
En este capítulo se hablará acerca de los resultados obtenidos al utilizar buenas
prácticas dentro del desarrollo de software, así como los beneficios obtenidos por
parte de la empresa interesada en la construcción del mismo. Donde se describirán
los beneficios y técnicas para el mantenimiento del software.
Análisis de datos
El uso de tecnologías de la información es un trabajo difícil y complejo que requiere
una base sólida de la aplicación de los conceptos fundamentales de áreas como las
ciencias de la computación y los sistemas de información [52].
Con esto, es beneficiosa la implementación de buenas prácticas para el
desarrollo de software, ya que estas ayudan a facilitar la aplicación de los conceptos,
así como la mejora de la lógica de pensamiento para encontrar la solución a los
diversos problemas que se enfrentan los desarrolladores de software.
Uno de los puntos más importantes es que al implementar un buen
diseño, el precio a pagar por un proyecto no crece y evita la modificación al momento
de la construcción, y cada vez que pase más tiempo para realizar la corrección, más
elevado será el precio para modificar el proyecto, ya que cada de construcción, la
complejidad del proyecto crece y las relaciones entre los módulos se incrementan.
A continuación, se muestra una gráfica donde se valoran los costos de
implementación de correcciones en base al tiempo.
85
En la construcción, se decidió utilizar tecnologías de Microsoft ya que,
en base a las nuevas actualizaciones que se encuentra recibiendo, permitirán su uso
en múltiples plataformas, no solamente en sistemas operativos de base Windows.
Todo esto surge gracias a la aparición de Mono, que es un software de plataforma
diseñado para que desarrolladores de .Net puedan crear aplicaciones
multiplataforma.
Además, la aparición de .Net Core como infraestructura para su uso en
múltiples ambientes, Xamarin para el desarrollo de aplicaciones móviles utilizando
C# y WPF (Windows Presentation Foundation), desarrollo de videojuegos con Unity y
desarrollo de aplicaciones web. Estas herramientas pueden ser utilizadas en base de
un lenguaje común, C#. Por lo cual, la curva de aprendizaje puede ser un poco larga
al principio, pero después, ya que las tecnologías se basan en el mismo lenguaje
nada más con otro tipo de implementación, es mucho más sencillo comprender como
los otros tipos de herramientas pueden ser utilizadas e implementadas.
C#, así como otros lenguajes, puede ser un lenguaje fácil de
comprender e implementar cuando se utilizan buenas prácticas en la construcción de
software, como se mencionaba anteriormente con los ADT, por ejemplo, que ayudan
a modular el flujo de información dentro del sistema. Esto con el objetivo de
Figura 43. Costos de implementación de cambios en base al tiempo.
Fuente: Code Complete 2nd Edition, Steve McConnell, Página 30, Capitulo 3
86
encapsular información y evitar que otras partes del sistema puedan obtener
información que no es necesaria para su funcionamiento, de manera que ayude a
mantener la privacidad de la información. Esto ayuda, a que el mantenimiento sea
algo más sencillo, ya que con ello solo se tendrá que modificar en un solo lugar la
funcionalidad.
Esto conlleva el utilizar las conocidas clases y métodos, las cuales
ayudan a evitar la repetición de código, modular el acceso a la información y la
separación de intereses.
Los resultados obtenidos en base la aplicación de esta tecnología y
buenas prácticas en la construcción, hacen que un sistema pueda ser fácil de
comprender para aquellos que se integren para continuar con el desarrollo del
mismo, proveer un mantenimiento con mayor facilidad, y evitar correcciones que no
son necesarias para la mejora del software.
CAPÍTULO 5
DISCUSIÓN
88
Conclusiones
En base a la investigación realizada durante las estadías, se pudieron comprender
muchas definiciones teóricas y prácticas para el desarrollo de software en el campo
laborar, con el objetivo de obtener un mejor rendimiento para tener un desarrollo
fluido y constante para que los clientes puedan observar avances en el desarrollo del
sistema de información que ellos requieren.
Comprendiendo esto, cualquier sistema sin importar el tamaño o nivel
de complejidad, será fácil de plasmar en código utilizando siempre una buena
metáfora con la cual representarlo de manera sencilla. En base a esa metáfora,
establecer el camino a seguir para obtener la solución que se adapte mejor a la
necesidad a solucionar, y empezar a desarrollar la idea, ya que ese es el objetivo de
una metáfora. No es mostrar cómo hacer las cosas, sino ayudar a encontrar el
camino a seguir para una solución óptima.
Como muchos autores mencionan, es difícil establecer todos los
requerimientos de un software al momento de diseñarlo, ya que el cliente, cuando
comienza la construcción, se dan cuenta que muchas cosas no eran como
imaginaba, y tendrían que rediseñarse las partes del sistema que se consideraban
correctas o incluso crearse otras nuevas. Por lo cual, es bueno tener maneras de
manejar las correcciones que se vayan presentando en el proceso de construcción.
Por último, como desarrolladores de software, es indispensable el tener
una buena aplicación en lo que desarrollamos, ya sea para un tipo de infraestructura,
o un lenguaje de programación en específico como lo es Java o PHP, es bueno
implementar las mejores herramientas que ofrecen, así como comprender como
plasmar las ideas en código, ya que no todos los lenguajes aplican la misma lógica
de la misma manera, para unos puede tan solo costar 5 líneas de código, y para
otros unas 10, pero conociendo a profundidad el lenguaje, esas 10 líneas se podrían
transformar en 8 o 7, ya que probablemente la metáfora utilizada era buena mas no
la correcta.
89
Recomendaciones y/o sugerencias
- Seguir un patrón de diseño para los proyectos que se empiezan por parte de la
empresa en el departamento de desarrollo.
- Establecer una planeación detallada de lo que se realizara en la fase de
construcción.
- Definir la metáfora a utilizar que ayudara a seguir el camino que ayudara a
solucionar el problema del cliente.
- Utilizar buenas prácticas en el desarrollo de aplicaciones como lo son, buena
abstracción y encapsulación de la información dentro de la aplicación.
90
Bibliografía
[1] J. Doe, «Wikipedia,» Wikipedia, 6 Febrero 2006. [En línea]. Available:
https://es.wikipedia.org/wiki/Planificaci%C3%B3n_de_los_requerimientos_de_mat
erial. [Último acceso: 12 Octubre 2017].
[2] O. Corporation, «Oracle,» Oracle Corporation, [En línea]. Available:
https://www.oracle.com/mx/applications/erp/what-is-erp.html. [Último acceso: 14
Octubre 2017].
[3] A. Powell-Morse, «AirBrake,» 6 December 2016. [En línea]. Available:
https://airbrake.io/blog/sdlc/waterfall-model. [Último acceso: 14 October 2017].
[4] GoodReads, «GoodReads,» [En línea]. Available:
https://www.goodreads.com/book/show/4845.Code_Complete. [Último acceso: 14
Octubre 2017].
[5] S. McConnell, «Welcome to Software Construction,» de Code Complete, Second
ed., Washington DC, Redmond: Microsoft Press, 2004, p. 7.
[6] S. McConnell, Code Complete, Second ed., Washington, Redmond: Microsoft
Press, 2004, p. 18.
[7] S. McConnel, «Metaphors for a Richer Understanding of Software Development,»
de Code Complete, Second ed., Washington, Redmond: Microsoft Press, 2004, p.
9.
[8] S. McConnel, «Design in Construction,» de Code Complete, Second ed.,
Washington, Redmond: Microsoft Press, 2004, p. 107.
[9] R. A. Española, «RAE,» [En línea]. Available: http://dle.rae.es/?id=YErlG2H.
[Último acceso: 08 Noviembre 2017].
[1
0]
J. P. Porto, «Definicion De,» 2008. [En línea]. Available:
https://definicion.de/software/. [Último acceso: 14 Octubre 2017].
[1
1]
I. Bonilla, «Desarrollo de Sistemas Profesionales,» 12 Noviembre 2012. [En
línea]. Available: http://dsp.mx/blog/sistemas-de-informacion/53-que-es-un-
sistema-de-informacion. [Último acceso: 14 Octubre 2017].
[1 J. P. Porto, «Definicion De,» 2008. [En línea]. Available:
91
2] https://definicion.de/empresa/. [Último acceso: 15 Octubre 2017].
[1
3]
J. Doe, «Wikipedia,» 6 Febrero 2006. [En línea]. Available:
https://es.wikipedia.org/wiki/Planificaci%C3%B3n_de_los_requerimientos_de_mat
erial. [Último acceso: 16 Octubre 2017].
[1
4]
J. Doe, «Wikipedia,» 17 Marzo 2010. [En línea]. Available:
https://es.wikipedia.org/wiki/Sistema_de_planificaci%C3%B3n_de_recursos_empr
esariales. [Último acceso: 16 Octubre 2017].
[1
5]
M. Solorio, «Metodologia en Cascada,» 16 Abril 2013. [En línea]. Available:
http://metodologiaencascada.blogspot.mx/. [Último acceso: 16 Octubre 2017].
[1
6]
J. P. Porto y A. Gardey, «Definicion De,» 2008. [En línea]. Available:
https://definicion.de/metafora/. [Último acceso: 16 Octubre 2017].
[1
7]
S. McConnel, «Welcome to Software Construction,» de Code Complete,
Washington, Microsoft Press, 2004, p. 3.
[1
8]
J. P. Porto y A. Gardey, «Definicion De,» 2008. [En línea]. Available:
https://definicion.de/programacion/. [Último acceso: 16 Octubre 2017].
[1
9]
S. McConnel, «Welcome to Software Construction,» de Code Complete,
Washington, Microsoft Press, 2004, p. 7.
[2
0]
M. Merino, «Definicion De,» 2010. [En línea]. Available:
https://definicion.de/algoritmo/. [Último acceso: 10 Noviembre 2017].
[2
1]
S. McConnel, «Metaphors for a Richer Understanding of Software Development,»
de Code Complete, Washington, Microsoft Press, 2004, p. 12.
[2
2]
S. McConnel, «Measure Twice, Cut Once: Upstream Prerequisites,» de Code
Complete, Washington, Microsoft Press, 2004, p. 25.
[2
3]
A. Gardey, «Definicion De,» 2008. [En línea]. Available:
https://definicion.de/planificacion/. [Último acceso: 10 Noviembre 2017].
[2
4]
S. McConnel, «Measure Twice, Cut Once: Upstream Prerequisites,» de Code
Complete, Washington, Microsoft Press, 2004, p. 39.
[2
5]
IsraelCCM., «CCM,» CCM, 27 marzo 2017. [En línea]. Available:
http://es.ccm.net/contents/304-lenguajes-de-programacion. [Último acceso: 11
92
Noviembre 2017].
[2
6]
F. R. Sierra, «Paradigma Digital,» 18 Febrero 2016. [En línea]. Available:
https://www.paradigmadigital.com/dev/el-indice-tiobe-como-medir-que-lenguajes-
de-programacion-son-los-mas-usados/. [Último acceso: 21 Noviembre 2017].
[2
7]
B. W. Boehm, Software Cost Estimation with Cocomo II, California: Financial
Times Prentice Hall, 2000.
[2
8]
S. McConnel, «Design in Construction,» de Code Complete, Washington,
Microsoft Press, 2004, p. 80.
[2
9]
J. Doe, «StackOverflow,» [En línea]. Available:
https://stackoverflow.com/questions/1692933/what-is-an-abstract-data-type-in-
object-oriented-programming. [Último acceso: 11 Noviembre 2017].
[3
0]
U. o. Wisconsin-Madison, «Computer Sciences User Pages,» University of
Wisconsin-Madison, [En línea]. Available: http://pages.cs.wisc.edu/~cs367-
1/readings/Introduction/index.html#benefits. [Último acceso: 7 Noviembre 2017].
[3
1]
N. C. Corporation, «Oracle Documents,» Oracle, 11 Diciembre 1998. [En línea].
Available: https://docs.oracle.com/cd/E19957-01/816-6411-10/intro.htm#1009369.
[Último acceso: 30 Noviembre 2017].
[3
2]
J. Doe, «Wikipedia,» 15 Septiembre 2016. [En línea]. Available:
https://es.wikipedia.org/wiki/Brendan_Eich. [Último acceso: 30 Noviembre 2017].
[3
3]
J. Doe, «Wikipedia,» 06 Noviembre 2014. [En línea]. Available:
https://es.wikipedia.org/wiki/JavaScript. [Último acceso: 30 Noviembre 2017].
[3
4]
J. Doe, «Mas Adelante,» [En línea]. Available:
http://www.masadelante.com/faqs/css. [Último acceso: 30 Noviembre 2017].
[3
5]
J. Doe, «Wikipedia,» 19 Noviembre 2004. [En línea]. Available:
https://es.wikipedia.org/wiki/Control_de_versiones. [Último acceso: 30 Noviembre
2017].
[3
6]
Badgerati, «Computer Science Source,» 25 Mayo 2010. [En línea]. Available:
https://computersciencesource.wordpress.com/2010/05/25/acid/. [Último acceso:
20 Noviembre 2017].
[3 J. Doe, «Wikipedia,» 20 Agosto 2008. [En línea]. Available:
93
7] https://es.wikipedia.org/wiki/Microsoft_SQL_Server. [Último acceso: 27 Octubre
2017].
[3
8]
C. Trovamala, N. Bahena y A. Romero, «Grid Morelos,» Universidad Autonoma
del Estado de Morelos, 20 Enero 2014. [En línea]. Available:
http://www.gridmorelos.uaem.mx/~mcruz/cursos/miic/sql5.pdf. [Último acceso: 28
Octubre 2017].
[3
9]
Microsoft, «MSDN,» Microsoft, [En línea]. Available:
https://msdn.microsoft.com/es-es/library/dn878908(v=vs.110).aspx. [Último
acceso: 18 Octubre 2017].
[4
0]
B. Wagner, «Docs Microsoft,» Microsoft, [En línea]. Available:
https://docs.microsoft.com/es-es/dotnet/csharp/getting-started/introduction-to-the-
csharp-language-and-the-net-framework#c-language. [Último acceso: 29 Octubre
2017].
[4
1]
J. Doe, «Wikipedia,» 24 Enero 2008. [En línea]. Available:
https://es.wikipedia.org/wiki/C_Sharp. [Último acceso: 21 Octubre 2017].
[4
2]
Microsoft, «MSDN,» Microsoft, [En línea]. Available:
https://msdn.microsoft.com/es-es/library/bb399567(v=vs.110).aspx. [Último
acceso: 21 Octubre 2017].
[4
3]
W. T. Surveys, «W3Techs,» Web Technology Surveys, Noviembre 2017. [En
línea]. Available: https://w3techs.com/technologies/overview/javascript_library/all.
[Último acceso: 7 Noviembre 2017].
[4
4]
J. Foundation, «jQuery,» Jquery Foundation, [En línea]. Available:
https://jquery.org/license/. [Último acceso: 21 Octubre 2017].
[4
5]
J. Doe, «Wikipedia,» 20 Septiembre 2007. [En línea]. Available:
https://es.wikipedia.org/wiki/JQuery#Caracter.C3.ADsticas. [Último acceso: 29
Octubre 2017].
[4
6]
T. Rodríguez, «GenBeta,» 16 Junio 2012. [En línea]. Available:
https://www.genbetadev.com/frameworks/bootstrap. [Último acceso: 3 Noviembre
2017].
[4
7]
S. Stain, B. Hamilton, M. Taveggia y C. Guyer, «Docs Microsoft,» Microsoft, 10
Septiembre 2017. [En línea]. Available: https://docs.microsoft.com/en-
us/sql/ssms/download-sql-server-management-studio-ssms. [Último acceso: 19
94
Octubre 2017].
[4
8]
Git, «Git SCM,» Git, [En línea]. Available: https://git-scm.com/. [Último acceso: 18
Noviembre 2017].
[4
9]
J. Doe, «Wikipedia,» 26 Octubre 2007. [En línea]. Available:
https://es.wikipedia.org/wiki/Git#Caracter.C3.ADsticas. [Último acceso: 29 Octubre
2017].
[5
0]
Microsoft. [En línea]. Available: https://www.visualstudio.com/es/thank-you-
downloading-visual-studio/?sku=Community&rel=15.
[5
1]
B. Wagner, «Microsoft Docs,» Microsoft, 20 Julio 2015. [En línea]. Available:
https://docs.microsoft.com/en-us/dotnet/csharp/language-
reference/keywords/namespace. [Último acceso: 7 Noviembre 2017].
[5
2]
J. Doe, «Wikipedia,» 11 Septiembre 2015. [En línea]. Available:
https://es.wikipedia.org/wiki/Tecnolog%C3%ADas_de_la_informaci%C3%B3n_y_l
a_comunicaci%C3%B3n. [Último acceso: 31 Octubre 2017].
[5
3]
M. Rouse, «Search SQL Server,» TechTarget, Agosto 2017. [En línea]. Available:
http://searchsqlserver.techtarget.com/definition/SQL-Server. [Último acceso: 11
Noviembre 2017].
[5
4]
D. Engines, «db-engines.com,» solid IT gmbh, Noviembre 2017. [En línea].
Available: https://db-engines.com/en/ranking. [Último acceso: 9 Noviembre 2017].
