UNIVERSIDAD TECNOLÓGICA DE TABASCO.
DIVISIÓN DE TECNOLOGÍA DE LA INFORMACIÓN Y COMUNICACIÓN
TSU EN ENTORNOS VIRTUALES Y NEGOCIOS DIGITALES:
Actividad:
Investigación
NOMBRE DEL ALUMNO:
Barahona González Axel Alonso
MATRÍCULA:
42210300
GRADO Y GRUPO:
2 “A”
MATERIA:
Programación Estructurada
PROFESOR:
Yesenia Madrazo Cruz
PARRILLA, CENTRO, TABASCO, ENERO DEL 2025
Indice
UNIVERSIDAD TECNOLÓGICA DE TABASCO. ............................................................... 1
DIVISIÓN DE TECNOLOGÍA DE LA INFORMACIÓN Y COMUNICACIÓN ....................... 1
introducción ....................................................................................................................... 3
Clasificación de paradigmas de programación ................................................................... 4
▪ Paradigmas Imperativos ......................................................................................... 4
1. Programación Estructurada ................................................................................ 4
2. Programación Procedimental ............................................................................. 4
3. Programación Modular ....................................................................................... 4
▪ Programación Declarativos .................................................................................... 6
1. Programación Lógica.......................................................................................... 6
2. Programación Funcional ..................................................................................... 6
Entornos de desarrollo integrados ..................................................................................... 7
Tipos de lenguajes de programación estructurada ......................................................... 7
Fases de implementación en programación estructurada .............................................. 7
SDKs .............................................................................................................................. 8
Entorno de desarrollo integrado ..................................................................................... 8
Buenas prácticas de codificación ..................................................................................... 11
Documentación de Código ............................................................................................... 13
Conclusión ....................................................................................................................... 16
Referencias Bibliográficas ............................................................................................... 17
Introducción
La programación, como disciplina fundamental en el desarrollo de software, se organiza en
paradigmas que guían las metodologías y enfoques utilizados en la resolución de problemas
computacionales. Estos paradigmas, como los imperativos y declarativos, permiten estructurar de
manera lógica y eficiente el código para el desarrollo de aplicaciones funcionales. Dentro de los
paradigmas imperativos, destacan enfoques como el estructurado, procedimental y modular,
mientras que los paradigmas declarativos incluyen el lógico y funcional. La correcta selección y
aplicación de estos paradigmas es crucial para abordar las problemáticas específicas de cada
proyecto.
Por otro lado, los entornos de desarrollo integrados (IDE) facilitan la implementación de estos
paradigmas al proporcionar herramientas que optimizan el proceso de programación. Estas
herramientas incluyen editores de código, sistemas de control de versiones, depuradores y
extensiones que aumentan la productividad y calidad del software. Asimismo, las buenas prácticas
de codificación y la adecuada documentación del código son esenciales para garantizar la legibilidad,
mantenibilidad y escalabilidad de las soluciones computacionales, promoviendo así un desarrollo
ético y colaborativo en los equipos de trabajo.
En este contexto, la incorporación de herramientas generativas como el Prompt Engineering
representa un avance en la documentación automatizada, agilizando la creación de software. De
esta forma, se fomenta la profesionalización del desarrollo de soluciones tecnológicas mediante la
integración de procesos estandarizados y buenas prácticas que aseguren la calidad del producto
final.
Clasificación de paradigmas de programación
Los paradigmas de programación son enfoques para resolver problemas mediante la escritura de
código, basados en diferentes filosofías de como estructurar y manipular la información.
▪ Paradigmas Imperativos
El paradigma imperativo es un estilo de programación que se basa en la ejecución
secuencial de instrucciones. En este paradigma, el programador describe paso a paso cómo
se debe ejecutar el código.
1. Programación Estructurada
▪ Características: Se enfoca en la organización del código mediante bloques lógicos, utilizando
estructuras de control como secuencias , selecciones y bucles, eliminando el uso de
instrucciones de salto como goto.
▪ Diferencias: A diferencia de la programación secuencial , promueve una mayor claridad y
mantenimiento del código .
▪ Aplicaciones: Adecuada para proyectos donde la claridad y la facilidad de mantenimiento
son prioritarios
2. Programación Procedimental
▪ Características: Organiza el código en procedimientos o funciones que realizan tareas
específicas, facilitando la reutilización y modularidad
▪ Diferencias: A diferencia de la programación estructurada , permite la creación de funciones
que pueden ser llamadas múltiples veces, reduciendo la redundancia .
▪ Aplicaciones: Ideal para proyectos que requieren una clara división de tareas y reutilización
de código.
3. Programación Modular
▪ Características: Divide el código en módulos independientes que interactúan entre si,
promoviendo la encapsulación y la separación de responsabilidades.
▪ Diferencias: A diferencia de la programación procedimental, los módulos pueden ser
desarrollados y probados de manera independiente, facilitando el mantenimiento y la
escabilidad.
▪ Aplicaciones: Útil en proyectos grandes y complejos donde la división del trabajo y la gestión
de equipos son esenciales.
▪ Programación Declarativos
El paradigma declarativo es un estilo de programación que se basa en describir el resultado
deseado, en lugar de los pasos para llegar a él. Se utiliza en el desarrollo de sitios web,
bases de datos, plantillas y gestión de configuración.
1. Programación Lógica
▪ Característica : Se basa en la lógica formal , donde los programas consisten en hechos y
reglas que definen relaciones entre entidades.
▪ Diferencias: A diferencia de la programación imperativa , no especifica como se deben
realizar las operaciones, sino que relaciones deben cumplirse .
▪ Aplicaciones: Adecuada para sistemas expertos, bases de datos y aplicaciones que
requieren inferencia lógica .
2. Programación Funcional
▪ Características : Se centra en el uso de funciones puras y evita el estado mutable y los
efectos secundarios, promoviendo la inmutabilidad y la transparencia referencial.
▪ Diferencias: A diferencia de la programación imperativa, no se basa en la ejecución
secuencial de instrucciones, sino en la evaluación de funciones.
▪ Aplicaciones: Ideal para aplicaciones que requieren alta concurrencia, procesamiento de
datos y sistemas donde la predictibilidad y la facilidad de prueba son críticas.
Entornos de desarrollo integrados
La programación estructurada promueve la claridad y la eficiencia en el desarrollo de software
mediante la organización lógica del código. A continuación, se detallan los procesos de desarrollo
en la programación estructurada, incluyendo los tipos de lenguajes , las fases de implementación y
los SDKs
Tipos de lenguajes de programación estructurada
Los lenguajes de programación estructurada están diseñados para facilitar la escritura de código
claro y mantenible. Algunos de los mas destacados son:
• C: Uno de los lenguajes mas influyentes, conocido por su eficiencia y control de bajo nivel .
• Pascal: Diseñado para enseñar buenas prácticas de programación, enfatizando la claridad
y la estructura.
• Ada: Utilizado en aplicación críticas, como sistemas de defensa y aeroespaciales, debido a
su robustez y fiabilidad.
• Fortran: Aunque mas antiguo, sigue siendo relevante en aplicaciones científicas y de
ingeniera por su rendimiento en cálculos numéricos.
Fases de implementación en programación estructurada
El proceso de desarrollo en programación estructurada se puede dividir en varias fases clave.
• Análisis del problema: Comprensión detallada del problema a resolver, recopilando
requisitos y definiendo objetivos claros.
• Diseño: Planificación de la solución mediante diagramas de flujo y pseudocodigo ,
estableciendo la estructura y los algoritmos necesarios.
• Codificación: Escritura del código fuente en el lenguaje seleccionado, siguiendo las
prácticas de programación estructurada.
• Pruebas:Verificación de que el software cumple con los requisitos especificados,
identificando y corrigiendo errores.
• Mantenimiento: Actualización y mejora del software después de su implementación,
respondiendo a cambios en los requisitos o corrigiendo defectos .
SDKs
Un SDK es un conjunto de herramientas y bibliotecas que facilitan el desarrollo de aplicaciones para
una plataforma especifica. Proporciona recursos como compiladores, depuradores, documentación
y ejemplos de código. Por ejemplo, el kt de desarrollo de Java (JDK) incluye herramientas esenciales
para desarrollar aplicaciones en java
Entorno de desarrollo integrado
Un Entorno de Desarrollo Integrado (IDE) es una aplicación de software que proporciona
herramientas esenciales para el desarrollo de aplicaciones, combinando funcionalidades que facilitan
la escritura, prueba y depuración del código.
Editores de Código:
▪ Funcionalidades:
• Resaltado de sintaxis: Destaca palabras clave, variables y estructuras del lenguaje de
programación, mejorando la legibilidad del código
• Autocompletado: Sugiere y completa automáticamente fragmentos de código,
acelerando la escritura y reduciendo errores.
• Refactorizacion: Permite modificar la estructura del código sin alterar su funcionalidad,
facilitando mejoras y mantenimiento.
• Navegación Rápida: Facilita el desplazamiento entre archivos y funciones,
optimizando la gestión de proyectos grandes.
▪ Componentes Internos:
• Análisis léxico y sintáctico: Procesa el código para identificar errores y sugerir
correcciones.
• Gestión archivos: Organiza y maneja los archivos del proyecto, permitiendo una
estructura coherente
▪ Componentes externos:
• Integración con sistemas de control de versiones: Facilita la gestión de cambios y
colaboración en equipo.
• Soporte para Plugins: Permite ampliar las funcionalidades del editor según las
necesidades del desarrollador.
Herramientas de depuración:
▪ Funcionalidades:
• Puntos de Interrupción (Breakpoints): Permiten detener la ejecución del programa en
puntos específicos para inspeccionar el estado.
• Inspección de Variables: Muestra el valor de las variables en tiempo real, facilitando
la identificación de errores.
• Seguimiento de la Ejecución: Permite ejecutar el código paso a paso para entender
el flujo y detectar fallos.
▪ Componentes Internos:
• Interfaz de Depuración: Proporciona una interfaz gráfica para controlar y visualizar el
proceso de depuración.
• Integración con el Compilador: Permite compilar y ejecutar el código en modo de
depuración.
Herramientas de control de versiones:
▪ Funcionalidades:
• Gestión de Cambios: Registra y organiza las modificaciones realizadas en el código
fuente.
• Colaboración en Equipo: Facilita la integración de cambios de múltiples
desarrolladores.
• Historial de Versiones: Permite acceder a versiones anteriores del código y revertir
cambios si es necesario.
▪ Componentes internos:
• Integración con el Sistema de Archivos: Gestiona las versiones de los archivos del
proyecto.
• Interfaz de Usuario: Proporciona herramientas gráficas para visualizar y gestionar el
historial de versiones.
▪ Componentes Externos:
• Integración con Repositorios Remotos: Permite sincronizar el código con servidores
externos, facilitando la colaboración.
• Soporte para Diversos Sistemas de Control de Versiones: Compatible con
herramientas como Git, SVN, Mercurial, entre otros
Plugins/Extensiones:
▪ Funcionalidades
• Ampliación de Capacidades: Añade nuevas funcionalidades al IDE, como soporte para
nuevos lenguajes o herramientas adicionales.
• Personalización del Entorno: Permite adaptar el IDE a las preferencias y necesidades
específicas del desarrollador.
▪ Componentes Internos
• Gestor de Plugins: Administra la instalación, actualización y configuración de plugins.
• API de Extensiones: Proporciona interfaces para que los desarrolladores creen y
compartan sus propios plugins.
▪ Componentes Externos:
• Repositorios de Plugins: Fuentes externas donde se pueden descargar e instalar
plugins desarrollados por la comunidad o proveedores terceros.
• Integración con Servicios Externos: Algunos plugins pueden interactuar con servicios
en la nube, bases de datos o herramientas de terceros.
Buenas prácticas de codificación
La adopción de buenas practicas de codificación y documentación es esencial para garantizar la
legibilidad y mantenibilidad del código en soluciones computacionales .
1. Nombres Significativos :
• Variables y Funciones: Utilizar nombres descriptivos que reflejen claramente su
propósito facilita la comprensión del Código
2. Consistencia en el estilo de codificación :
• Convenciones de Nomenclatura: Adoptar un estilo uniforme, como camelCase o
snake_case, y aplicarlo de manera consistente en todo el código.
• Indentación y Espaciado: Mantener una indentación coherente mejora la estructura
visual del código, facilitando su lectura.
3. Cometarios y documentación:
• Comentarios Relevantes: Incluir comentarios que expliquen la funcionalidad de bloques
de código complejos, evitando comentarios obvios o redundantes.
• Documentación de Funciones y Métodos: Proporcionar descripciones claras sobre el
propósito, parámetros y valores de retorno de las funciones.
4. Estructura y organización del codigo:
• Modularidad: Dividir el código en funciones o métodos que realicen tareas específicas
promueve la reutilización y facilita el mantenimiento.
• Evitar la Duplicación: Aplicar el principio DRY (Don't Repeat Yourself) para minimizar la
redundancia y mantener la coherencia.
5. Pruebas y validación:
• Desarrollo Basado en Pruebas (TDD): Escribir pruebas unitarias junto con el código
ayuda a garantizar su fiabilidad y facilita futuras modificaciones.
6. Uso de herramienta de control de versiones :
• Sistemas como Git: Permiten gestionar cambios, colaborar con otros
desarrolladores y mantener un historial del código, lo que es fundamental para la
mantenibilidad.
7. Refactorización Regular:
• Mejora Continua: Revisar y mejorar el código periódicamente para optimizar su
estructura y rendimiento sin alterar su funcionalidad.
Documentación de Código
El uso de herramientas generativas de programación, como modelos de inteligencia artificial (IA), ha
revolucionado la manera en que se aborda la programación estructurada. Estas herramientas, que
dependen de técnicas como Prompt Engineering, se han convertido en un valioso apoyo en diversas
etapas del ciclo de vida del desarrollo de software. A continuación, se explica su uso y beneficios en
el contexto de la programación estructurada:
1. ¿Qué es Prompt Engineering en Programación?
El Prompt Engineering es la práctica de diseñar y ajustar instrucciones (prompts) para que un modelo
de IA, como ChatGPT o Codex, genere resultados relevantes y útiles. En programación, implica
redactar solicitudes específicas para:
• Generar código.
• Explicar conceptos complejos.
• Depurar errores.
• Optimizar algoritmos.
2. Aplicaciones en Programación Estructurada
a. Generación de Código Estructurado
• Cómo funciona: Los desarrolladores pueden solicitar a la IA que genere fragmentos de
código, especificando las estructuras requeridas (por ejemplo, un ciclo for o una función
modular).
• Ejemplo:
Prompt: "Escribe una función en C que calcule el promedio de un arreglo de números
enteros."
Respuesta: La IA genera una función modular con las mejores prácticas de programación
estructurada.
b. Refactorización y Optimización
• Uso: Rediseñar código existente para hacerlo más claro, eficiente y acorde a las reglas de
la programación estructurada.
• Ejemplo:
Prompt: "Reescribe este código en Python para que sea más legible usando programación
estructurada."
c. Generación de Documentación
• Cómo ayuda: Las herramientas generativas pueden crear comentarios y documentaciones
para funciones y programas, asegurando que sean claros y útiles.
• Ejemplo:
Prompt: "Documenta esta función en lenguaje natural y agrega ejemplos de uso."
d. Depuración de Código
• Uso: La IA puede identificar errores en el código y sugerir soluciones.
• Ejemplo:
Prompt: "Encuentra el error en este código y corrígelo."
e. Generación de Pseudocódigo
• Cómo funciona: Se puede pedir a la herramienta que convierta un problema en
pseudocódigo, facilitando el diseño estructurado antes de implementar en un lenguaje
específico.
• Ejemplo:
Prompt: "Escribe el pseudocódigo para un programa que ordene un arreglo usando el
método de burbuja."
f. Aprendizaje y Educación
• Aplicación: Las herramientas generativas pueden explicar conceptos de programación
estructurada, ayudando a nuevos desarrolladores a comprender principios básicos como la
modularidad, la reutilización de código y el control de flujo.
• Ejemplo:
Prompt: "Explica el concepto de programación modular con ejemplos."
3. Beneficios para la Programación Estructurada
• Eficiencia: Genera código más rápido, ahorrando tiempo en tareas repetitivas.
• Mejoras en la calidad: Las herramientas suelen seguir buenas prácticas, generando código
legible y bien estructurado.
• Soporte a desarrolladores: Actúan como asistentes, ayudando a resolver problemas técnicos
rápidamente.
• Facilitación de la colaboración: Documentación y ejemplos generados automáticamente
mejoran la comunicación entre equipos.
4. Ejemplo Práctico
Prompt:
"Crea un programa en C estructurado que calcule la suma de los números pares en un rango
especificado por el usuario."
Resultado de la Herramienta Generativa:
La IA devuelve un programa bien estructurado que incluye:
1. Declaración de funciones modulares (calcularSumaPares).
2. Uso de estructuras claras (for para iterar en el rango).
3. Comentarios relevantes para cada bloque de código.
5. Limitaciones y Precauciones
Aunque son herramientas poderosas, es importante:
• Revisar y validar el código generado para evitar errores o problemas de seguridad.
• No depender completamente de ellas, ya que no reemplazan el juicio crítico y la experiencia
del desarrollador.
Conclusión
La programación moderna requiere de un conocimiento sólido de los paradigmas, las herramientas
y las prácticas que conforman el desarrollo de software. La correcta aplicación de paradigmas, el
uso eficiente de entornos integrados y la implementación de buenas prácticas no solo optimizan los
procesos técnicos, sino que también contribuyen a un entorno de trabajo colaborativo y ético.
Además, la evolución de herramientas generativas ofrece nuevas posibilidades para mejorar la
documentación y el mantenimiento del código, garantizando soluciones computacionales de alta
calidad. Por lo tanto, la formación en estas áreas es fundamental para los profesionales del software,
quienes deben estar preparados para adaptarse a los constantes avances tecnológicos y las
exigencias del mercado.
Referencias Bibliográficas}
Microsoft. (n.d.). Introduction to Visual Studio. Microsoft Learn. Recuperado el [15/01/25], de
https://learn.microsoft.com/en-us/visualstudio/get-started
JetBrains. (n.d.). What is an Integrated Development Environment (IDE)? Recuperado el
[15/01/2025], de https://www.jetbrains.com/idea/features/
W3Schools. (n.d.). Programming Paradigms. Recuperado el [15/01/2025], de
https://www.w3schools.com/whatis/whatis_programming_paradigms.asp
FreeCodeCamp. (2021). Best Practices for Writing Clean Code. Recuperado el [15/01/2025], de
https://www.freecodecamp.org/news/best-practices-for-writing-clean-code/
IBM. (n.d.). What is Prompt Engineering? Recuperado el [15/01/2025], de
https://www.ibm.com/cloud/learn/prompt-engineering
UNIVERSIDAD TECNOLÓGICA DE TABASCO.
DIVISIÓN DE TECNOLOGÍA DE LA INFORMACIÓN Y COMUNICACIÓN
TSU EN TIC ÁREA ENTORNOS VIRTUALES Y NEGOCIOS DIGITALES.
ACTIVIDAD:
IDE
NOMBRE DEL ALUMNO
Axel Alonso Barahona Gonzalez
MATRICULA:
422410300
GRADO Y GRUPO:
2 “A”
MATERIA:
Programacion Estrucutrada
PROFESOR:
Yesenia Madrazo Cruz
Indice
El IDE ................................................................................................................................ 3
Pasos para instalara el JDK .................................................................................................... 8
MinGW .............................................................................................................................. 9
El IDE
NetBeans es un entorno de desarrollo integrado de código abierto,utilizado principalmente para el
desarrollo de aplicaciones en java , pero también es compatible con otros lenguajes de
programación.
▪ Aplicación: NetBeans
▪ Version: 24.0
▪ Dispositivo: Laptop
▪ Enlace de descarga: https://netbeans.apache.org/front/main/index.html
Requisitos para su uso :
• Sistema operativo compatible: Windows, macOS, Linux
• Versión de Java requerida: JDK 17 o superior
• Espacio en disco necesario: Aproximadamente 2 GB
• Memoria RAM recomendada: 4 GB o más
• Procesador: Intel o AMD de al menos 2 GHz
• Formato del archivo descargado: Instalador ejecutable (.exe para Windows, .dmg para
macOS, .tar.gz para Linux)
• Tamaño del archivo: Aproximadamente 400 MB (puede variar según la plataforma)
Pasos de instalación
Paso 1: En el navegador de tu preferencia buscaremos NetBeans y se dará click en el primer enlace
Paso 2:
Daremos click en el recuadro verde para poder descargarlo
Paso 3:
Nos redireccionara en la pagina donde se encuentra los enlaces de descarga y eligiremos el enlace
de acuerdo a nuestro software en este caso Windows x64.
Paso 4 :
Ya que elegimos nuestro enlace de descarga nos redireccionara a otra pagina con en enlace de
descarga del IDE
Paso 5:
Una vez ya descargado en nuestra carpeta de descargas nos aparecerá y le damos click para poder
abrirlo
Paso 6:
Se abrirá el instalador , en el apartado de customiza se pueden editar los lenguajes que se podrán
instalar una vez iniciado, luego apretaremos next
Paso 7:
Después nos preguntara en que carpeta deseamos que se guarden los datos y el paquete de
instalación , una vez seleccionado damos next
Paso 8:
Después nos mostrara la barra de descarga al finalizar nos mostrara la siguiente pantalla. Daremos
click en finish y ya estará lista la instalacion.
Pasos para instalara el JDK
Un JDK (Java Development Kit) es un conjunto de herramientas que permite a los desarrolladores
crear, compilar, ejecutar y depurar aplicaciones en el lenguaje de programación Java. Es esencial
para cualquier persona que desee desarrollar software en Java.
Paso 1:
Poner en el navegador java jdk 24 download apretaras el primer enlace
Paso 2:
En el apartado de Windows apretaras x64 installer para iniciar la descarga del paquete ( esto es
importante para poder ejecutar NetBeans).
MinGW
MinGW (Minimalist GNU for Windows) es un conjunto de herramientas de desarrollo que permite
compilar y ejecutar aplicaciones nativas de Windows utilizando herramientas de la colección GNU
(como gcc, g++ y make). Proporciona un entorno liviano para desarrollar software en C, C++ y otros
lenguajes compatibles con los compiladores de GNU en sistemas Windows.
Paso 1:
Esto es importante para poder utilizar C++ en NetBeans. Buscaremos MinGw y daremos clcik en el
primer enlace, Daremos en descargar, ejecutaremos el programa hasta llegar al instalador.
Paso 2 :
Una vex que llegamos a este apartado donde esta los paquetes de instalacion, los seleccionaremos
y daremos clcik en instalar , nos mostrara la opción de apply change y daremos click
Paso 3
Buscamos en nuestros archivos la carpeta MInGw, una vex dentro buscaremos la carpeta llamada
bin y entramos
Paso 4:
Bucaremos en la carpeta bin el archivo c++
Paso 6:
En el buscador de la lap , pondremos Editar las variables de entorno del sistema damos click , una
vez ya ejecutado daremos click en el recuadro variables de entorno.
Paso 7:
Buscaremos la palabra Path y daremos click en ella
Paso 8.
Una vez allí damos click en recuadro nuevo para agregar una variable de entorno y pegaremos las
direcciones de la carpeta bin y damos aceptar.
Al finalizar ejecutaremos el IDE al seleccionar el apartado file, daremos en new file , donde nos
mostara el listado ed lenguajes que podremos utilizar.
