UNIVERSIDAD TÉCNICA ESTATAL DE QUEVEDO

FACULTAD DE CIENCIA DE LA INGENIERÍA

INGENIERÍA EN SOFTWARE

ASIGNATURA

CONSTRUCCIÓN DE SOFTWARE

CURSO

VI “A”

TEMA

HERRAMIENTAS DE CONSTRUCCIÓN

AUTOR

DE LA CRUZ GENDE LUIS ALFREDO

DOCENTE

ING. GUERRERO ULLOA GLEISTON CICERON

SEGUNDO PERIODO ACADÉMICO

2021 – 2022
Contenido
1 Introducción .............................................................................................................. 4

2 Entornos de Desarrollo ............................................................................................. 5

2.1 Utilidad .............................................................................................................. 5

2.2 Niveles del entorno de desarrollo ...................................................................... 5

2.2.1 Entorno de desarrollo.................................................................................. 5

2.2.2 Entorno de integración................................................................................ 5

2.2.3 Entorno de prueba o testing ........................................................................ 5

2.2.4 Entornos de desarrollo integrado en la nube .............................................. 6

2.3 Entornos de desarrollo más populares ............................................................... 6

2.3.1 Eclipse ........................................................................................................ 6

2.3.2 NetBeans ..................................................................................................... 7

2.3.3 IntelliJ Idea ................................................................................................. 7

2.3.4 Visual Studio .............................................................................................. 8

2.3.5 Visual Studio Code ..................................................................................... 9

2.4 Google Trends .................................................................................................... 9

3 Constructores de GUI ............................................................................................. 10

3.1 Descripción ...................................................................................................... 10

3.2 Widgets ............................................................................................................ 10

3.3 Entornos de desarrollo con constructores de GUI ........................................... 11

3.3.1 Eclipse con WindowBuilder ..................................................................... 11

3.3.2 Visual Studio con Windows Form ........................................................... 11

3.3.3 API de Java (AWT y Swing) .................................................................... 13

4 Herramientas de pruebas unitarias .......................................................................... 14

4.1 JUnit ................................................................................................................. 14

4.2 Spring Test ....................................................................................................... 15

 4.2.1 Provee ....................................................................................................... 15

4.2.2 Requisitos del Pruebas de Estado Final .................................................... 15

4.3 Cactus............................................................................................................... 15

5 Herramientas de Perfiles ......................................................................................... 16

5.1 Perfilados basado en eventos ........................................................................... 16

5.2 Perfilado de ejecución ...................................................................................... 17

5.3 Perfilado de bloqueo ........................................................................................ 17

5.4 Perfilado de paralelismo .................................................................................. 18

6 Análisis de rendimiento .......................................................................................... 18

6.1 Características .................................................................................................. 18

6.2 Cuando realizar el análisis de rendimiento ...................................................... 19

7 Conclusión .............................................................................................................. 20

8 Bibliografía ............................................................................................................. 20
1 Introducción
El desarrollo de Software es un proceso complejo y a menudo difícil que requiere la
síntesis de muchos sistemas. Desde el modelado y diseño hasta el código, administración
del proyecto, pruebas, despliegue, administración de cambios y más.

Las herramientas para desarrollo de software pueden tener diversos propósitos como
compiladores, editores de código, diseñadores de interfaz gráfica, ensambladores,
depuradores, herramientas de análisis de rendimiento, etc.

Las soluciones ofrecidas por esas herramientas pueden aplicarse en diferentes áreas de la
programación y ayudar en el desarrollo de las tareas más complejas hasta las más simples,
en la actualidad existe múltiples herramientas para desarrollar un software, y decir que
una de ellas es la mejor es simplemente una mentira, eso va a depender de cada persona
que la esté utilizando o se sienta más cómodo.

En la presente investigación se buscó las herramientas que posiblemente sean las mas
utilizadas y con ello se define brevemente su funcionalidad y como utilizarlas, ya sean
herramientas de entornos de desarrollo, la ayuda de construir interfaces de diseño, como
realizar las pruebas unitarias en una herramienta especifica como JUnit, y como analizar
el rendimiento del software.
2 Entornos de Desarrollo
Es un conjunto de operaciones y herramientas utilizadas por los desarrolladores para
codificar, generar, depurar, actualizar, integrar, testear, validar y ejecutar programas [1].

Es un espacio de trabajo en el que los cambios se realizan en diferentes ambientes hasta

que se ponen en marcha en la versión real, es decir la versión del usuario final.

2.1 Utilidad

Básicamente, implementar un entorno de desarrollo sirve para facilitar el trabajo realizado

por los desarrolladores, efectuar un control de versiones, realizar pruebas y actualizar la
documentación de un proyecto. Este tipo de metodología consiente que el desarrollo de
software se ejecute de forma ágil, disminuyendo los tiempos [2].

2.2 Niveles del entorno de desarrollo

En el desarrollo de software viven diferentes entornos de desarrollo que se utilizan a

medida que va surgiendo el proyecto.

2.2.1 Entorno de desarrollo

El entorno de desarrollo se refiere a la creación del software[2]. Este entorno puede ser
implementado a nivel local, en la computadora del desarrollador o en un servidor local.

En este espacio de trabajo el programador codifica, realiza pruebas y comprueba la

ejecución del código.

2.2.2 Entorno de integración

Es usual que trabaje un conjunto de desarrolladores en un proyecto, lo que hace que se

cumplan tareas de forma particular[2]. El entorno de integración proporciona la unión de
los diferentes desarrollos y admite comprobar que los diferentes trabajos no obstruyan
entre sí.

2.2.3 Entorno de prueba o testing

Este tipo de entorno comúnmente está situado en la nube. La ventaja de contar con un
servidor de pruebas es que admite a otros desarrolladores del equipo y clientes a
interactuar con el software para realizar tests de funcionalidades del sistema [2].

También se pueden realizar testing mecanizados, su principal objetivo es detectar el

mayor número de fallos posible, al no necesitar una persona que realice un testeo manual
permite ahorrar tiempo. Además, la ejecución de pruebas automatizadas permite ejecutar
tests durante las 24 horas del día los 7 días de la semana.

2.2.4 Entornos de desarrollo integrado en la nube

Cuando se trabaja con un entorno de desarrollo cloud no es necesario descargar el

software, el sistema no consume una gran cantidad de recursos informáticos y no hay que
realizar configuraciones locales [2]. Todo esto tiene como consecuencia que el entorno
de desarrollo se pueda utilizar de forma inmediata y los desarrolladores puedan colaborar
en los diferentes proyectos de forma rápida.

Este tipo de implementación también influye en el equipo, ya que no es necesario que

todos los desarrolladores se encuentren en el mismo lugar, sino que pueden contribuir
desde diferentes puntos y dispositivos, algo que hoy en día se valora mucho debido a los
cambios que ha traído el teletrabajo.

Además, los entornos en la nube permiten una gestión centralizada, ya que ningún código
se encuentra en el ordenador de un desarrollador, ni hay diferentes versiones sin control
pasando de una persona a otra.

2.3 Entornos de desarrollo más populares

Recomendar el mejor IDE para trabajar no es tarea fácil. Cada programador tiene sus
preferencias y lo que para algunos es cómodo para otros puede resultar lo contrario [2].
Es como hablar de coches. Algunos estarán encantados con coches de marcas asiáticas,
otros preferirán europeas y siempre habrá quienes prefiera un auto americano o ruso. Así
que lo mejor es enumerar aquellos IDE que son más populares para que los conozcas y
puedas probar aquel que mejor se le ajuste.

2.3.1 Eclipse

Es un IDE muy popular de código abierto y ampliamente extendido. Fue desarrollador

originalmente por IBM aunque actualmente cuenta con una gran comunidad que le da
soporte con una gigantesca biblioteca de plugins. Es multiplataforma (Windows, Linux y
Mac) y dispone de nuevas versiones cada año. Con Eclipse es posible desarrollar todo
tipo de aplicaciones para web, escritorio o móviles usando Java, C, C++, JSP, perl,
Python, Ruby y PHP.
 Imagen 1. Entorno de desarrollo Eclipse

2.3.2 NetBeans

NetBeans es otro entorno de desarrollo integrado basado en código abierto. Muchas

personas les gustan dicho IDE porque gracias a su enfoque se puede desarrollar
aplicaciones como módulos (como un componente de un software). Lo cual resulta
sumamente cómodo pues se puede reutilizar el código para diferentes proyectos las veces
que se requiera sin mayor complicación. NetBeans es el IDE oficial de Java, pero también
se puede desarrollar en otros lenguajes como PHP, C, C++ e incluso HTML 5.

Imagen 2. Entorno de desarrollo de NetBeans

2.3.3 IntelliJ Idea

Desarrollado por Jet Brains es un IDE que cuenta con dos versiones, la Community
Edition, libre descarga, y la versión Ultimate Edition que cuesta más de 500 dólares de
suscripción anual, según el plan que se contrate, pero que se puede probar gratis durante
30 días.

Imagen 3. Entorno de desarrollo de IntelliJ Idea

Con IntelliJ se puede programar sobre diferentes lenguajes y proporciona soporte para
trabajar con JAVA, Node JS, PHP, Python, Ruby, Sass, TypeScript, AngularJS,
CoffeeScript, CSS, HTML, JavaScript, LESS, etc.

Además, ofrece integración con GIT lo que permite trabajar con diferentes versiones del
software sin afectar a la línea maestra del desarrollo.

2.3.4 Visual Studio

Visual Studio es un IDE para desarrollar interfaces gráficas de usuario (GUI), formularios
de Windows, juegos, servicios y aplicaciones web.

Imagen 4. Entorno de desarrollo de Visual Studio

Desde la versión 2017, este IDE propiedad de Microsoft y disponible para Windows y
Mac, permite desarrollar, por medio de sus herramientas, aplicaciones para Windows,
Linux, macOS, Android y iOS.

2.3.5 Visual Studio Code

Desde la versión 2017, este IDE propiedad de Microsoft y disponible para Windows y
Mac, permite desarrollar, por medio de sus herramientas, aplicaciones para Windows,
Linux, macOS, Android y iOS.

Imagen 5. Entorno de desarrollo del Visual Studio Code

Además, cuenta con soporte, nativo y por medios de complementos, para un gran número
de lenguajes de programación, como JavaScript, TypeScrip, Node.js, C++, C#, Java,
Python, PHP, Go. .NET, entre otros.

2.4 Google Trends

En la Imagen 6, se puede visualizar la tendencia de uso que tiene los entornos de

desarrollo anteriormente mencionados, donde se puede notar que en primer lugar se tiene
el entorno de Visual Studio Code, según las estadísticas de Google Trends.

Imagen 6. Nivel de tendencia que tienen cada uno de los entornos de desarrllo mencionados, según Google Trends
3 Constructores de GUI
Un constructor de GUI (Graphical User Interface / Interfaz gráfica de usuario) es una
herramienta de desarrollo de software que permite al desarrollador crear y mantener GUIs
en modo WYSIWYG (what you see is what you get / lo que ves es lo que hay) [3]. Un
constructor de GUI suele incluir un editor visual para que el desarrollador diseñe
formularios y ventanas y gestione la disposición de los widgets arrastrando, soltando y
parametrizando. Algunos constructores de GUI pueden generar automáticamente el
código fuente correspondiente al diseño visual de la GUI.

Dado que las aplicaciones GUI actuales suelen seguir el estilo "event-driven" (en el que
el flujo del programa viene determinado por los eventos y la gestión de los mismos) [3],
las herramientas de construcción de GUI suelen proporcionar asistentes de generación de
código, que automatizan las tareas más repetitivas necesarias para la gestión de eventos.
El código asistente conecta los widgets con los eventos salientes y entrantes que activan
las funciones que proporcionan la lógica de la aplicación.

3.1 Descripción

Estas herramientas generan directamente código fuente en uno o más idiomas de destino
(como el diseñador de Windows Forms en Visual Studio) o crean archivos de recursos
(generalmente basados en XML) que son independientes del idioma en el que se usarán
(como el diseñador de WPF para Visual Studio, Glade para GTK + o Interface Builder
para Mac OS X ).

Un constructor de GUI es una herramienta de desarrollo de software que permite al

desarrollador visualizar una interfaz gráfica de usuario (GUI, por sus siglas en inglés)
interactiva [4]. Esta herramienta de desarrollo de software se utiliza en el diseño de
aplicaciones de escritorio.

Existen muchos constructores de GUI disponibles en el mercado, tales como el entorno

de desarrollo Eclipse, el entorno de desarrollo Qt, el entorno de desarrollo Visual Studio,
el entorno de desarrollo NetBeans, etc.

3.2 Widgets

Es una "subaplicación" especial con una interfaz gráfica de usuario (GUI) que consiste
en componentes de interfaz de usuario, como campos de texto, paneles con pestañas,
ventanas de video, etc. Los widgets son buenos para construir formularios, Gráficos y
diagramas, mapas dinámicos e interfaces hombre-máquina (HMI) [5]. Estás interfaces se
pueden usar para controlar, configurar y monitorear diferentes dispositivos de hardware
o componentes del sistema.

3.3 Entornos de desarrollo con constructores de GUI

3.3.1 Eclipse con WindowBuilder

Permite desarrollar rápidamente una interfaz Gráfica de Usuario (GUI) por medio de una
paleta de componentes con tan solo arrastrar y soltar, generando el código necesario para
su funcionamiento.

El código generado no requiere bibliotecas personalizadas adicionales para compilar y

ejecutar, todo el código generado se puede usar sin tener instalado WindowBuilder [5].
WindowBuilder puede leer y escribir casi cualquier formato y aplicar ingeniería inversa
a la mayoría de los códigos GUI de Java escritos a mano. También es compatible con la
edición de código de forma libre (haga cambios en cualquier lugar, no solo en áreas
especiales) y la mayoría de las refactorizaciones de usuario (puede mover, renombrar y
subdividir métodos sin ningún problema).

Imagen 7. Entorno de desarrollo de un Constructor de GUI en Eclipse

3.3.2 Visual Studio con Windows Form

Windows Form es una herramienta para crear componentes gráficos de Windows

mediante el lenguaje de programación C# [3]. Los componentes gráficos de Windows
son un tipo de componente .NET que se puede utilizar en el entorno Windows Forms.
3.3.2.1 Componentes

Los objetos visuales de Windows Forms se dividen en 4 categorías:

• Control, UserControl y Form: La clase Control es la clase base que tiene la

funcionalidad de todos los controles que se usan en un formulario (clase Form)
[5]. Mientras que la clase User Control sirve para crear controles personalizados
que están compuestos por otros controles Windows.
• Controls: Se refiere a los controles Windows que al arrastrarse a un formulario
se muestran en el diseñador de formularios de Visual Studio .NET [5], tales como
controles de entrada de datos: TextBox y ComboBox, de salida de datos: Label y
ListView, de comandos: Button y ToolBar, etc.
• Componentes: Los componentes son clases similares a los controles pero que no
heredan del Control y que al arrastrarse a un formulario no se ven en el diseñador
de formularios sino en el diseñador de componentes de visual studio .NET, tales
como componentes de información al usuario [5]: ToolTip y ErrorProvider,
componentes de menús: MainMenu y ContextMenu, componentes de ayuda: Help
y HelpProvider.
• Common Dialog Boxes: Los cuadros de diálogos comunes son objetos que al
arrastrarse al formulario también se ubican en el Diseñador de Componentes de
Visual Studio .NET, tales como diálogos de archivos: OpenFileDialog y
SaveFIleDialog, diálogos de color: ColorDialog, diálogos de Fuentes: FontDialog
y los diálogos de impresión: PrintDialog, PageSetupDialog y PrintPreviewDialog.

Imagen 8. Entorno de desarrollo para componentes de Windows Form

3.3.3 API de Java (AWT y Swing)

La API de Java proporciona dos bibliotecas de clases para el desarrollo de Interfaces

gráficas de usuario [6]. La biblioteca proporciona un conjunto de herramientas para la
construcción de interfaces gráficas que tienen una apariencia y se comportan de forma
semejante en todas las plataformas en las que se ejecuten.

La estructura básica de la biblioteca gira en torno a componentes y contenedores. Los

contenedores contienen componentes y son componentes a su vez, de forma que los
eventos pueden tratarse tanto en contenedores como en componentes [6]. La API está
constituida por clases, interfaces y derivaciones.

3.3.3.1 AWT (Abstract Window Toolkit)

Imagen 9. Algunos componentes de AWT

Es un kit de herramientas de gráficos, interfaz de usuario, y sistema de ventanas

independiente de la plataforma original de Java. AWT es ahora parte de las Java
Foundation Classes (JFC) - la API estándar para suministrar una interfaz gráfica de
usuario (GUI) para un programa Java.

3.3.3.2 Swing

Es la evolución del AWT, la cual al igual que Swing es un conjunto de librerías enfocadas
a la construcción de interfaces, solo que con esta se presentaron algunos problemas en
cuanto a portabilidad principalmente cuando se desarrollaban aplicaciones para diferentes
sistemas operativos, pues el comportamiento de los componentes gráficos en ocasiones
podía variar [6].
 Imagen 10. Algunos componentes de Swing

4 Herramientas de pruebas unitarias

Las pruebas unitarias verifican el funcionamiento de los módulos de software aislados de
otros elementos de software que se pueden probar por separado (por ejemplo, clases,
rutinas, componentes) [7]. Las pruebas unitarias suelen estar automatizadas. Los
desarrolladores pueden utilizar herramientas y marcos de pruebas unitarias para ampliar
y crear un entorno de pruebas automatizado.

Con las herramientas y los marcos de pruebas unitarias, el desarrollador puede codificar
criterios en la prueba para verificar la corrección de la unidad bajo varios conjuntos de
datos [7]. Cada prueba individual se implementa como un objeto, y un corredor de
pruebas ejecuta todas las pruebas. Durante la ejecución de la prueba, los casos de prueba
fallidos se marcarán automáticamente y se informará de ellos.

4.1 JUnit

JUnit es un framework de código abierto desarrollado especialmente para crear, ejecutar

y hacer reportes de estado de conjuntos de Prueba Unitaria automatizadas hechos en
lenguaje Java [8]. JUnit es uno de los frameworks más populares en Java para realizar
pruebas unitarias y llevar un desarrollo utilizando la práctica de Test Driven
Development.

JUnit ha sido una innovación importante para la industria de las pruebas de software. Por
un lado, ha llevado a la industria de las pruebas de software a adquirir una mayor
conciencia de cómo debe llevarse a cabo el desarrollo de software [8]. Por el otro, ha
llevado también a la industria a considerar la necesidad de aplicar la programación
orientada a objetos por lo que JUnit es una gran fuente de ideas para el desarrollo de
software orientado a objetos.
4.2 Spring Test

Es un conjunto de pruebas de carga y de estrés de manera que los datos demuestren que
el producto o sistema es seguro [8]. Este proceso se lleva a cabo en un ambiente
controlado y bajo condiciones de prueba.

Spring Framework contiene un conjunto de clases pensadas para realizar Prueba Unitaria
y Prueba De Integracion, facilitando varias tareas repetitivas. En particular, estas
utilidades se integran directamente con JUnit.

4.2.1 Provee

• Integración con Junit.

• Acceso al factory de beans directamente desde los test unitarios.
• Inyección automática de la clase bajo test en el TestCase.
• Rollback automático de transacciones contra bases de datos.
• Acceso a la conexión jdbc para realizar querys de comprobación.

4.2.2 Requisitos del Pruebas de Estado Final

A diferencia de las pruebas de carga, las pruebas de estado final se llevan a cabo en
ambientes reales. A continuación, se presentan las pruebas de estado final que un
fabricante debe realizar antes de aprobar el producto:

4.2.2.1 Pruebas de estado final

Prueba de vida útil: se realiza una prueba para valorar la vida útil del producto, para lo
que se exige que el producto pueda funcionar y operar de forma aceptable durante el
periodo de vida útil de la garantía.

• Pruebas de estrés: para probar el producto en condiciones extremas y valorar su

desempeño. Estas pruebas se llevan a cabo en un ambiente real.

4.3 Cactus

Cactus es un simple framwork de pruebas para Prueba Unitaria de código Java (Servlets,
EJB, TagLib, etc) [9]. Cactus intenta simplificar la escritura de pruebas del lado del
servidor. Usa JUnit y lo extiende.

El proceso de ejecución de Cactus se divide en dos partes: Cliente (Cliente) y Servidor

(Servidor).
 • Parte del cliente: Primero construya los parámetros de solicitud que se enviarán al
servidor. Después de que el cliente construye los parámetros de solicitud a través
de los métodos begin y beginXXX, establece una conexión HTTP con el servidor
y luego envía la solicitud al servidor.
• Del lado del servidor: la clase más importante es la clase ServletTestRedirector.
Es un servlet. Recibe una solicitud del cliente y genera una instancia de la clase
de prueba a través de la reflexión. Luego llama a sus métodos setUp, textXXX,
tearDown. Para enviar una respuesta al cliente (Respuesta).

Cliente: después de recibir la respuesta, ejecute los métodos endXXX y end para
completar el proceso de prueba.

Métodos ejecutados en el cliente: begin, beginXXX, endXXX, end.

Métodos ejecutados en el servidor: setUp, testXXX, tearDown.

5 Herramientas de Perfiles
En la programación las herramientas de perfiles ayudan a eliminar el trabajo repetitivo y
a concentrar el enfoque de las tareas, en las tareas realmente críticas.

Las herramientas de análisis de rendimiento suelen utilizarse para apoyar el ajuste del
código. Las herramientas de análisis de rendimiento más comunes son las de creación de
perfiles [1]. Una herramienta de perfilado de ejecución monitoriza el código mientras se
ejecuta y registra cuántas veces se ejecuta cada sentencia o cuánto tiempo pasa el
programa en cada sentencia o ruta de ejecución. El perfilado del código mientras se
ejecuta permite saber cómo funciona el programa, dónde están los puntos calientes y
dónde deben centrar los desarrolladores sus esfuerzos de ajuste del código.

5.1 Perfilados basado en eventos

Los lenguajes de programación enumerados aquí tienen perfiladores basados en eventos:

• Java: la API JVMTI (JVM Tools Interface), anteriormente JVMPI (JVM Profiling
Interface), proporciona enlaces a los perfiladores, para atrapar eventos como
llamadas, class-load, unload, thread enter y dejar.
• .NET: Puede adjuntar un agente de creación de perfiles como servidor COM al
CLR mediante la API de creación de perfiles. Al igual que Java, el tiempo de
ejecución proporciona varias devoluciones de llamada al agente, para atrapar
eventos como el método JIT / entrar / salir, creación de objetos, etc.
 Particularmente poderoso porque el agente de generación de perfiles puede
reescribir el código de bytes de la aplicación de destino de formas arbitrarias.
• Python: la creación de perfiles de Python incluye el módulo de perfil, hotshot (que
se basa en un gráfico de llamadas) y el uso de la función 'sys.setprofile' para
atrapar eventos como c_ {llamada, devolución, excepción}, python_ {llamada,
devolución, excepción}.
• Ruby: Ruby también usa una interfaz similar a Python para la creación de perfiles.
Se encuentran presentes flat-profiler en profile.rb, module y ruby-prof a C-
extensión.

5.2 Perfilado de ejecución

La herramienta de perfilado de ejecución es un programa que se encuentra dentro del

código a perforar [1]. Para ello, el perfilador debe introducirse en cada una de las rutas
que aparecen en la hoja de cálculo del programa a perforar.

Esto puede hacerse de diferentes maneras:

• Con una variable que muestre el número de veces que se ejecuta cada ruta de la
ejecución del programa.
• Que registre todo lo que ocurre durante la ejecución del programa, incluyendo
todas las llamadas del sistema.
• Que registre el tiempo que está el procesador ejecutando cada ruta o sentencia.

5.3 Perfilado de bloqueo

Esta herramienta permite que la ejecución del código se detenga cada vez que se produzca
un bloqueo. El efecto de un bloqueo es que todos los procesos que dependen del bloqueo
también se detienen [1]. El perfilador de bloqueo registra cuánto tiempo pasa el
procesador en un bloqueo y cuántas veces sucede. El perfilador de bloqueo es un
programa que se encuentra dentro del código a perforar. Para ello, el perfilador debe
plantearse en cada una de las rutas que aparecen en la hoja de cálculo del programa a
perforar.

Esto puede hacerse de diferentes maneras:

• Con una variable que muestre el número de bloqueos.

• Con una variable que muestre el tiempo que el procesador está en un bloqueo.
 • Con una variable que muestre el número de operaciones de bloqueo que se han
producido.
• Con una variable que muestre el tiempo que el procesador está ejecutando en un
bloqueo.

5.4 Perfilado de paralelismo

Esta herramienta permite que la ejecución del código se detenga cada vez que se
produzcan eventos de paralelismo. El efecto de un evento de paralelismo es que todos los
procesos que dependen del evento de paralelismo también se detienen [1]. El perfilador
de paralelismo registra cuánto tiempo pasa el procesador en un evento de paralelismo y
cuántas veces sucede. El perfilador de paralelismo es un programa que se encuentra
dentro del código a perforar. Para ello, el perfilador debe plantearse en cada una de las
rutas que aparecen en la hoja de cálculo del programa a perforar.

6 Análisis de rendimiento
En la programación el análisis de rendimiento consiste en la evaluación de la calidad del
producto, por lo que es importante que funcionen correctamente todos los productos y sus
funcionalidades [10]. Una vez que se ha determinado que los productos funcionan
correctamente, se puede proceder a realizar el análisis estructural.

Reside en la evaluación de tareas, de la calidad de los equipos que realizan esas tareas, de
los procesos y métodos utilizados, los controles existentes y el análisis de cambios [10].
En este análisis se consideran aspectos como: la eficiencia, el desempeño, la
productividad, la eficiencia de los procesos, la gestión de las tareas, los recursos, el
procedimiento de trabajo, los controles y la calidad, entre otros.

El análisis de rendimiento permite comprobar que el software realiza correctamente las

funciones que se han definido en el documento del producto.

6.1 Características

• El ajuste del código no puede considerarse una técnica de programación por sí

mismo, sino una parte de la programación.
• Puede ser considerado una práctica de revisión de código.
• La práctica de modificar el código existente para mejorar su operatividad o
eficiencia.
 • Puede ser una parte de ajuste de la arquitectura y puede tomar muchas formas.
Generalmente, se ajusta el código cuando el programa ya está escrito.
• El ajuste del código puede darse cuando se encuentra un bug en el programa o
cuando el programa no tiene el rendimiento que se esperaba.
• Se da cuando un programa ya está escrito y el programador encuentra una forma
más eficiente para escribir el código.

6.2 Cuando realizar el análisis de rendimiento

• El análisis de rendimiento se realiza en el ámbito de control de calidad del

proyecto, ya que debe ser realizado para las funcionalidades más críticas del
producto [10]. El análisis se realiza como una prueba de rendimiento con el fin de
sacar conclusiones.
• El análisis de rendimiento se realiza en conjunto con el análisis de requisitos. El
análisis de rendimiento es una prueba de rendimiento para verificar que los
requisitos del producto están siendo satisfechos por el software.
• Las pruebas de rendimiento deberían estar siempre presentes en los proyectos. Sin
embargo, esto no siempre es así [10]. Las pruebas de rendimiento son difíciles de
realizar, ya que dan poca información de los problemas de ejecución y son muy
costosas de realizar.
• El análisis de rendimiento se realiza en el ámbito de control de calidad del
proyecto. La meta del análisis de rendimiento es analizar el rendimiento del
producto para descubrir problemas [10]. Después de un análisis de rendimiento,
se elaboran conclusiones sobre el rendimiento de los productos.
7 Conclusión
Como se pudo observar el software de programación también es muy utilizado, no se
crean que se trabaja bajo un bloc de notas y a lo que Dios nos quiere dar a entender.

Se pudo ver algunas buenas herramientas para el diseño de software, en su gran mayoría
herramientas Open Source. Sin embargo, en lo que respecta a las metodologías de
desarrollo de software, la primera segmentación que se desarrolló podría decirse que fue
la más importante. Así que sin importar en que esquemas o entorno trabajes o si tienes en
mente basarte en alguna de las metodologías de desarrollo de software populares, debes
saber que todas y cada una de ellas te llegarán a servir en un determinado momento.

Por último, es impórtate recalcar que no importa que entorno o herramientas utilices para
alcanzar el objetivo de desarrollar un software, si es cierto que dependiendo de la
herramientas que utilices tal vez para algunas personas no será la adecuada, pero para
otras será la perfecta, porque de seguro ya tiene experiencia en utilizarla, de todos modos
lo importante no será la herramienta sino lo que vayas implementar con ella.

8 Bibliografía
[1] P. Bourque, R. E. Fairley, and I. C. Society, Guide to the Software Engineering
Body of Knowledge (SWEBOK(R)): Version 3.0, 3rd ed. Washington, DC, USA:
IEEE Computer Society Press, 2014.

[2] R. J. Ellison, “Software development environments: Research to practice,” 1986,

pp. 175–180. doi: 10.1007/3-540-17189-4_97.

[3] “Developing GUI Applications,” in Pro NetBeansTM IDE 6 Rich Client Platform
Edition, Berkeley, CA: Apress, pp. 403–443. doi: 10.1007/978-1-4302-0439-8_15.

[4] S. Adelsberger, A. Setzer, and E. Walkingshaw, “Developing GUI Applications in

a Verified Setting,” 2018, pp. 89–107. doi: 10.1007/978-3-319-99933-3_6.

[5] “GUI Components,” in Learn Cocoa on the Mac, Berkeley, CA: Apress, 2010, pp.
55–90. doi: 10.1007/978-1-4302-1860-9_4.

[6] H. Böck, “NetBeans Swing GUI Builder,” in The Definitive Guide to NetBeansTM
Platform 7, Berkeley, CA: Apress, 2012, pp. 439–457. doi: 10.1007/978-1-4302-
4102-7_41.

[7] G. O’Regan, “Software Testing Tools,” 2019, pp. 181–198. doi: 10.1007/978-3-
030-28494-7_10.
[8] D. Parsons, “Unit Testing with JUnit,” in Foundational Java, London: Springer
London, 2012, pp. 219–244. doi: 10.1007/978-1-4471-2479-5_10.

[9] J. U. Pipka, “Test-Driven Web Application Development in Java,” 2003, pp. 378–
393. doi: 10.1007/3-540-36557-5_27.

[10] A. Beigelbeck, M. Aniche, and J. Cito, “Interactive Static Software Performance

Analysis in the IDE,” in 2021 IEEE/ACM 29th International Conference on
Program Comprehension (ICPC), May 2021, pp. 490–494. doi:
10.1109/ICPC52881.2021.00057.