DIVISIÓN DE INGENIERIA EN SISTEMAS COMPUTACIONALES

Investigación Documental
“Conoce e identifica los diferentes tipos de optimización que permita eficientar el
código intermedio”

Asignatura:
Lenguajes y Autómatas II

Elaborado por:
Marya Fernanda Bautista Monter 183107254

Docente:
Ing. Brayan Antonio Mejía Díaz

Grupo:
363-M
Período: 2021-1
Contenido
Introducción ..................................................................................................................................... 3
3 Conoce e identifica los diferentes tipos de optimización que permita eficientar el código
intermedio......................................................................................................................................... 4
3.1 Tipos de Optimización ........................................................................................................... 4
3.1.1 Locales ....................................................................................................................... 4
3.1.2 Ciclos .......................................................................................................................... 4
3.1.3 Globales ...................................................................................................................... 5
3.1.4 De mirilla.................................................................................................................... 5
3.2 Costos ................................................................................................................................ 5
3.2.1 Costos de ejecución (memoria, registros, pilas .......................................................... 5
3.2.2 Criterios para mejorar el código ................................................................................. 6
3.2.3 Herramientas para el análisis del flujo de datos ......................................................... 6
Conclusion ........................................................................................................................................ 7
Referencias ....................................................................................................................................... 8
Introducción
Definitivamente la mejor forma de programar es teniendo en cuenta que probablemente el
ochenta por ciento de nuestras líneas de código (o más), tengan por lo menos un error, o en algún
momento nos marcaran el bello y diminuto zigzag rojo debajo de nuestra sentencia.
A pesar de que el ochenta o noventa por ciento de nuestro trabajo esté basado en lo que
podríamos llamar “prueba y error”, sabemos que no puede existir la prueba y error sin el error, y
no puede existir el error sin que alguien o algo nos diga que estamos en un error.
Llegando precisamente a este punto en el que necesitamos de una guía o un
acompañamiento a través de la creación y estructuración de un buen proyecto, podemos encontrar
como algunas muy buenas herramientas, el uso de algunas aplicaciones para desarrollar
programas, en vez de utilizar el no muy confiable o agradable archivo de texto.
Aun teniendo cada una de estas grandes herramientas que nos ayudan a detectar, nos dan
opciones para corregir nuestras equivocaciones, aportan rutas más fáciles para la creación de
código e incluso al momento de ejecutar y compilar el programa completo nos dicen el lugar
exacto en el que estamos cometiendo un error. Hay momentos en los que nos es completamente
imposible identificar el error que tenemos presente.
La realidad es que ninguno de nosotros somos completamente capaces de generar un
código cien por ciento libre de errores, ya que no tenemos la capacidad de reconocimiento y
memoria de cada una de estas ya mencionadas herramientas, sino que conocemos las sentencias
principales y las órdenes básicas que un programa debe llevar por lo menos para declarar
variables, reconocer algunas operaciones básicas o manipular cadenas de caracteres con las
operaciones más simples o comunes que conocemos.
Para realizar otro tipo de operaciones, generar una variedad de extensiones o incluso
importar o crear ciertas paqueterías, tenemos las maravillas de alguien más que decidió hacernos
la vida mucho más fácil, y con estos increíbles trabajos también podemos encontrar las palabras,
caracteres y funciones que nuestro programa o más bien lenguaje pueden reconocer (que no
siempre nos salvan la vida, pero sí son de gran ayuda).

3
 3 Conoce e identifica los diferentes tipos de optimización que
permita eficientar el código intermedio
3.1 Tipos de Optimización
Es el conjunto de fases de un compilador que transforman un fragmento de código en otro
fragmento con un comportamiento equivalente y que se ejecuta de forma más eficiente, es decir,
usando menos recursos de cálculo como memoria o tiempo de ejecución.
Las optimizaciones pueden realizarse de diferentes formas con base al alcance ofrecido
por el compilador. Depende del lenguaje de programación y es directamente proporcional al
tiempo de compilación.
Este es un proceso que tiende a minimizar o maximizar alguna variable de rendimiento,
generalmente tiempo, espacio, procesador, etc. La optimización se realiza reestructurando el
código de forma que el nuevo código tenga mayores beneficios.

3.1.1 Locales
Se realiza sobre módulos del programa. En la mayoría de las ocasiones a través de
funciones, métodos, procedimientos, clases, etc. Solo se ven reflejadas en las secciones locales.
Sirve cuando un bloque de programa o sección es crítico. Como el espacio de soluciones
es más pequeño, la optimización local es más rápida.

3.1.2 Ciclos
Se trata de una de las partes más esenciales en el rendimiento de un programa, dado que
realizan acciones repetitivas, y si dichas acciones están mal realizadas, el problema puede crecer
mucho más.
La mayoría de las optimizaciones sobre ciclos tratan de encontrar elementos que no deben
repetirse en un ciclo.
El problema de la optimización en ciclos y en general radica es que muy difícil saber el
uso exacto de algunas instrucciones. Así que no todo código de proceso puede ser optimizado.
Otros usos de la optimización pueden ser el mejoramiento de consultas en SQL o en
aplicaciones remotas

4
 3.1.3 Globales
Dada con respecto al código completo.
Este tipo de optimización es más lenta, pero tiene la capacidad de mejorar el desempeño
general de todo el programa y puede depender de la arquitectura de la máquina.
En algunos casos es mejor mantener variables globales para agilizar los procesos, pero
consume memoria. Algunas optimizaciones incluyen utilizar como variables registros del CPU o
utilizar instrucciones en ensamblador.

3.1.4 De mirilla
La optimización de mirilla trata de estructurar de manera eficiente el flujo del programa,
sobre todo en instrucciones de bifurcación como son las decisiones, ciclos y saltos de rutinas. La
idea es tener los saltos lo más cerca de las llamadas, siendo el salto lo más pequeño posible.

3.2 Costos
Los costos son el factor más importante para tomar en cuenta a la hora de optimizar ya
que en ocasiones la mejora obtenida puede verse no reflejada en el programa final, pero si ser
perjudicial para el equipo de desarrollo.
La optimización de una pequeña mejora tal vez tenga una pequeña ganancia en tiempo o
espacio, pero sale muy costosa en tiempo en generarla. Pero en cambio si esa optimización se
hace por ejemplo en un ciclo, la mejora obtenida puede ser N veces mayor por lo cual el costo se
minimiza y es benéfico la mejora.
3.2.1 Costos de ejecución (memoria, registros, pilas
Son aquellos que vienen implícitos al ejecutar el programa. En algunos programas se tiene
un mínimo para ejecutar el programa, por lo que el espacio y la velocidad de microprocesadores
son elementos que se deben optimizar para tener un mercado potencial más amplio.
Las aplicaciones multimedia como los videojuegos tienen un costo de ejecución alto por
lo cual la optimización de su desempeño es crítica, la gran mayoría de las veces requieren de
procesadores rápidos o de mucha memoria.
Los dispositivos móviles tienen recursos más limitados que un dispositivo de cómputo
convencional razón por la cual, el mejor uso de memoria y otros recursos de hardware tiene
mayor rendimiento.

5
 3.2.2 Criterios para mejorar el código
Los criterios de optimización siempre están definidos por el compilador.
La mejor manera de optimizar el código es hacer ver a los programadores que optimicen
su código desde el inicio, el problema radica en que el costo podría ser muy grande ya que tendría
que codificar más y/o hacer su código más legible.
Muchos de estos criterios pueden modificarse con directivas del compilador desde el
código o de manera externa. Este proceso lo realizan algunas herramientas del sistema como los
ofuscadores para código móvil y código para dispositivos móviles.

3.2.3 Herramientas para el análisis del flujo de datos

Existen algunas herramientas que permiten el análisis de los flujos de datos, entre ellas
tenemos los depuradores y desambladores.

Depurador
Es una aplicación que permite correr otros programas, permitiendo al usuario ejercer
cierto control sobre los mismos a medida que los estos se ejecutan, y examinar el estado del
sistema (variables, registros, banderas, etc.) en el momento en que se presente algún problema.
Éste permite detener el programa en:
• Un punto determinado mediante un punto de ruptura.
• Un punto determinado bajo ciertas condiciones mediante un punto de ruptura condicional.
• Un momento determinado cuando se cumplan ciertas condiciones.
• Un momento determinado a petición del usuario.

Durante la interrupción puede:

• Examinar y modificar la memoria y las variables del programa.
• Examinar el contenido de los registros del procesador.
• Cambiar el punto de ejecución, de manera que el programa continúe su ejecución en un
punto diferente al punto en el que fue detenido.
• Ejecutar instrucción a instrucción.
• Ejecutar partes determinadas del código, como el interior de una función, o el resto de
código antes de salir de una función.

6
 Desamblador
Es un programa de computadora que traduce el lenguaje de máquina a lenguaje
ensamblador, la operación inversa de la que hace el ensamblador.
Un desensamblador se diferencia de un decompilador, en que está dirigido a un lenguaje
de alto nivel en vez de al lenguaje ensamblador.
Son ampliamente utilizados para crackear programas y para realizar ingeniería inversa.
También son utilizados por desarrolladores de software, investigadores o estudiantes.

Conclusion
What would we do if we couldn't see our mistakes? That is the biggest issue that we could
imagine. We are available to make mistakes once, twice, third, or a million more times. The
problem when we make mistakes is when we can't see it.
Maybe in a current way in our life, we forget to do something or take a thing from the
table in the kitchen, or something like that usual mistakes. But at any time in the day, we will
notice about it even if we don't, it doesn't represent the end of the world.
Another case is an app. If we start to program and we aren't available to see that we have a
mistake, all the programs will fail. In that situation, we are sure in big troubles.
Of course, nothing of that could be possible if we hadn't found the best way to help
ourselves, but anyway, all that thigs as regular expressions are the things that make our life so
easy to make other life easy.
Now all that we have to do is try our best to make the fewer mistakes possible even if we
have a powerful tool as regular expressions.

7
Referencias
• Ullman, J. D. et al. (2007) Introducción a la teoría de autómatas, lenguajes y computación (3ª.
Ed.). Madrid: Pearson Educación. Disponible en: ELibro (Accediso: 28.04.2021)
• Clarisó, R., 2021. Optimización de código: un código más eficiente - Tecnología++. [online]
Tecnología++. Available at: <https://informatica.blogs.uoc.edu/optimizacion-de-codigo-un-
codigo-mas-eficiente/> [Accessed 28 April 2021].
• Olivares Rojas, J., 2021. Unidad VII Otimización. [online] Dsc.itmorelia.edu.mx. Available at:
<http://dsc.itmorelia.edu.mx/~jcolivares/courses/ps207a/ps2_u7.pdf> [Accessed 29 April
2021].
• Lenguajes y Autómatas 2, 2020. 3.2.3 Herramientas para Análisis del Flujo de Datos. [online]
Blogspot. Available at: <https://equiponegro8.blogspot.com/2020/03/3_53.html> [Accessed
28 April 2021].

8
 DIRECCIÓN ACADÉMICA

Guía estructurada de evaluación

FO-205P11000-13
División: (1) Ingeniería en Sistemas Computacionales
Docente: (2) Ing. Brian Antonio Mejía Díaz
Asignatura: (3) Lenguajes y Autómatas II
Nombre y número de
control:(5)
Bautista Monter Marya Fernanda 183107254 Grupo: (6) 363M

Evidencia de aprendizaje: (7) Investigación Documental

Criterios de evaluación:

CRITERIOS
SI NO
DE EVALUACIÓN OBSERVACIONES
• Contiene portada con las especificaciones (Nombre
del Docente, Nombre del Estudiante, # de control,
grupo y tema a investigar).

• Contiene introducción a 1 cuartilla.

• Contiene las tablas correspondientes a:
• Índice de Contenido
• Índice de Imágenes
Estructura del • Índice de Tablas
Documento Respectivamente y en caso de existir.
• Contiene desarrollo parafraseado y en ½ cuartilla, por
tema.
• Contiene conclusión de acuerdo con las
características propias de hacerlo en inglés y con sus
propias palabras, de acuerdo con el nivel que presente
sin utilizar ninguna clase de traductor a ½ cuartilla.
• Referencias Bibliográficas (al menos 2 libros)

• Faltas de Ortografía.

• Márgenes Definidos 2.5 por lado.

• Interlineado a 1.5 y justificado.

Características
del Documento • Los títulos y subtítulos se ven propiamente resaltados
y diferenciados el cuerpo del documento.
• Las referencias se encuentran en formato OXFORD.
• Entrega en tiempo y forma de acuerdo con las
indicaciones del docente.

1ª oportunidad 2ª oportunidad
Puntuación
Alcanzada (10)