En este texto se hablará sobre los conceptos

de programación vistos en la presentación.

Conceptos de
programación

JORGE ABRAHAM PANDURO VILLALBA

de ingeniería en sistemas computacionales
grupo c.
Materia: Fundamentos de la programación
Tabla de contenido
Conceptos de programación......................................................................................................0
Lenguaje Maquina..............................................................................................................................4
Página de investigación 1 (lenguaje maquina)...............................................................................4
Página de investigación 2 (lenguaje maquina)...............................................................................4
Lenguaje ensamblador.......................................................................................................................5
Página de investigación 1 (lenguaje ensamblador)........................................................................5
Características............................................................................................................................5
Ejemplos de mnemónicos en lenguaje ensamblador.................................................................6
Página de investigación 2 (lenguaje ensamblador)......................................................................10
Página de investigación 3 (lenguaje ensamblador)......................................................................11
Traductor de lenguajes de programación........................................................................................12
Página de investigación 1 (traductor de lenguajes)......................................................................12
Página de investigación 2 (traductor de lenguajes)......................................................................13
Intérpretes...............................................................................................................................13
Compiladores...........................................................................................................................13
Fases de la compilación............................................................................................................13
Página de investigación 3 (traductor de lenguajes)......................................................................14
Compiladores...........................................................................................................................15
Intérpretes...............................................................................................................................16
Compilador.......................................................................................................................................17
Página de investigación 1 (Compilador).......................................................................................17
La construcción de un compilador............................................................................................17
Página de investigación 2 (Compilador).......................................................................................19
Un poco de Historia..................................................................................................................19
Analizador léxico:.....................................................................................................................20
Analizador sintáctico:...............................................................................................................20
Analizador semántico:..............................................................................................................20
Editores de código o texto...............................................................................................................21
Página de investigación 1 (Editores de código o texto)................................................................21
Página de investigación 2 (Editores de código o texto)................................................................22
¿Para qué sirve el editor del texto?:.........................................................................................22
¿Qué empresas fabrican los editores de texto y su historia?:..................................................23
 Página de investigación 3 (Editores de código o texto)................................................................24
Usos de los editores de texto...................................................................................................24
Características de los editores de texto....................................................................................25
Depurador........................................................................................................................................25
Página de investigación 1 (depurador).........................................................................................25
Página de investigación 2 (depurador).........................................................................................26
Funciones básicas de un depurador.........................................................................................26
Soporte de hardware para depuradores..................................................................................26
Paquetes de herramientas de software...................................................................................27
Enlazadores......................................................................................................................................28
Página de investigación 1 (enlazadores).......................................................................................28
FUNCION DE LOS ENLAZADORES..............................................................................................28
ESTRUCTURA DE LOS ENLAZADORES........................................................................................29
TIPOS DE ENLAZADORES..........................................................................................................29
GENERALIDADES DE LOS ENLAZADORES DINÁMICOS..............................................................29
Generalidades de los Enlazadores Estáticos.............................................................................30
Página de investigación 1 (enlazadores).......................................................................................30
IDE....................................................................................................................................................31
Página de investigación 1 (IDE).....................................................................................................31
¿Por qué los desarrolladores utilizan los IDE?..........................................................................31
Tipos de IDE conocidos.............................................................................................................32
IDE para el desarrollo de aplicaciones móviles.........................................................................32
IDE de nube..............................................................................................................................32
GUI (interfaz gráfica de usuario)...............................................................................................33
Página de investigación 2 (IDE).....................................................................................................33
Bibliografía.......................................................................................................................................35
Lenguaje Maquina
Página de investigación 1 (lenguaje maquina)
El lenguaje de máquina o código máquina es el sistema de códigos directamente interpretable
por un circuito micro programable, como el microprocesador de una computadora o
el microcontrolador de un autómata. Este lenguaje está compuesto por un conjunto de
instrucciones que determinan acciones a ser tomadas por la máquina. Un programa consiste en
una cadena de estas instrucciones más un conjunto de datos sobre el cual se trabaja. Estas
instrucciones son normalmente ejecutadas en secuencia, con eventuales cambios de flujo
causados por el propio programa o eventos externos. El lenguaje de máquina es específico de
la arquitectura de la máquina, aunque el conjunto de instrucciones disponibles pueda ser similar
entre arquitecturas distintas.

Página de investigación 2 (lenguaje maquina)

Lenguaje de maquina: El lenguaje de maquina es aquel cuyas instrucciones son directamente
entendibles por la computadora y no necesitan traducción posterior para que la UCP pueda
comprender y ejecutar el programa.
Las instrucciones en lenguaje maquina se expresan en términos de la unidad de memoria más
pequeña (bit) = digito binario 0 o 1, en esencia una secuencia de bits que especifican la operación
y las celdas de memoria implicadas en una operación
 Ejemplo: Instrucciones en lenguaje de maquina:
 0010, 0000, 1001, 1001, 10001, 1110.
 Como se observa estas instrucciones son fáciles de leer por una computadora y difíciles para un
programador y viceversa. Por esta razón se hace difícil escribir programas en código o lenguaje de
máquina. Y se requiere otro lenguaje para comunicarse con la computadora pero que se hace más
fácil de escribir y de leer por el programador. Para evitar la tediosa tarea de escribir programas en
este lenguaje se han diseñado otros programas de programación que facilitan la escritura y
posterior ejecución de los programas.
Lenguaje ensamblador
Página de investigación 1 (lenguaje ensamblador)
El lenguaje ensamblador, o assembler (en inglés assembly language y la abreviación asm), es un
lenguaje de programación de bajo nivel. Consiste en un conjunto de mnemónicos que representan
instrucciones básicas para los computadores, microprocesadores, microcontroladores y otros
circuitos integrados programables. Implementa una representación simbólica de los códigos de
máquina binarios y otras constantes necesarias para programar una arquitectura de procesador y
constituye la representación más directa del código máquina específico para cada arquitectura
legible por un programador. Cada arquitectura de procesador tiene su propio lenguaje
ensamblador que usualmente es definida por el fabricante de hardware, y está basada en los
mnemónicos que simbolizan los pasos de procesamiento (las instrucciones), los registros del
procesador, las posiciones de memoria y otras características del lenguaje. Un lenguaje
ensamblador es por lo tanto específico de cierta arquitectura de computador física (o virtual). Esto
está en contraste con la mayoría de los lenguajes de programación de alto nivel, que idealmente
son portátiles.

Un programa utilitario llamado ensamblador es usado para traducir sentencias del lenguaje
ensamblador al código de máquina del computador objetivo. El ensamblador realiza una
traducción más o menos isomorfa (un mapeo de uno a uno) desde las sentencias mnemónicas a
las instrucciones y datos de máquina. Esto está en contraste con los lenguajes de alto nivel, en los
cuales una sola declaración generalmente da lugar a muchas instrucciones de máquina.

Muchos sofisticados ensambladores ofrecen mecanismos adicionales para facilitar el desarrollo del
programa, controlar el proceso de ensamblaje, y la ayuda de depuración. Particularmente, la
mayoría de los ensambladores modernos incluyen una facilidad de macro (descrita más abajo), y
se llaman macro ensambladores.

Fue usado principalmente en los inicios del desarrollo de software, cuando aún no se contaba con
potentes lenguajes de alto nivel y los recursos eran limitados. Actualmente se utiliza con
frecuencia en ambientes académicos y de investigación, especialmente cuando se requiere la
manipulación directa de hardware, alto rendimiento, o un uso de recursos controlado y reducido.
También es utilizado en el desarrollo de controladores de dispositivo (en inglés, device drivers) y
en el desarrollo de sistemas operativos, debido a la necesidad del acceso directo a las
instrucciones de la máquina. Muchos dispositivos programables (como los microcontroladores)
aún cuentan con el ensamblador como la única manera de ser manipulados.

Características

 El código escrito en lenguaje ensamblador posee una cierta dificultad de ser entendido
directamente por un ser humano ya que su estructura se acerca más bien al lenguaje
máquina, es decir, lenguaje de bajo nivel.
 El lenguaje ensamblador es difícilmente portable, es decir, un código escrito para un
Microprocesador, suele necesitar ser modificado, muchas veces en su totalidad para poder
 ser usado en otra máquina distinta, aun con el mismo Microprocesador, solo pueden ser
reutilizados secciones especiales del código programado.
 Los programas hechos en lenguaje ensamblador, al ser programado directamente sobre
Hardware, son generalmente más rápidos y consumen menos recursos del sistema
(memoria RAM y ROM). Al programar cuidadosamente en lenguaje ensamblador se
pueden crear programas que se ejecutan más rápidamente y ocupan menos espacio que
con lenguajes de alto nivel.
 Con el lenguaje ensamblador se tiene un control muy preciso de las tareas realizadas por
un Microprocesador por lo que se pueden crear segmentos de código difíciles de
programar en un lenguaje de alto nivel.
 También se puede controlar el tiempo en que tarda una Rutina en ejecutarse, e impedir
que se interrumpa durante su ejecución.
 El lenguaje ensamblador es un código estructurado y gravitatorio desarrollado sobre un
archivo de programación (.ASM), en el cual pueden existir varios programas, macros o
rutinas que pueden ser llamados entre sí

Ejemplos de mnemónicos en lenguaje ensamblador

¿Qué es un mnemónico?
En informática, un mnemónico es una palabra que sustituye a un código de operación (lenguaje de
máquina), lo que facilita la programación, lo que guarda mucha relación con el lenguaje
ensamblador.
En muchas ocasiones se puede tomar a nivel de usuario como las teclas de acceso rápido que
vemos en las ventanas, por ejemplo en un navegador encontramos el menú típico que dice
Archivo, Editar, Ver, entre otras opciones, el mnemónico sería el valor de la letra que esta
subrayada, así si presionamos la tecla alt y luego por ejemplo la A, se nos abrirá el menú de
archivo, es por esta razón que se puede decir que la A en el menú resulta la tecla mnemónica de
Archivo, o la tecla de acceso rápido a la opción Archivo.
El lenguaje Mnemónico también es utilizado en la programación de procesadores lógicos
programables (PLC), haciendo más rápida y eficiente la construcción de programas de alta
complejidad.

Dentro de los principales mnemónico tenemos:

MOV (transferencia)
Sintaxis: MOV dest, origen.
Transfiere datos de longitud byte o palabra del operando origen al operando destino. Pueden ser
operando origen y operando destino cualquier registro o posición de memoria direccionada de las
formas ya vistas, con la única condición de que origen y destino tengan la misma dimensión.
Existen ciertas limitaciones, como que los registros de segmento no admiten el direccionamiento
inmediato: es incorrecto MOV DS,4000h; pero no lo es por ejemplo MOV DS,AX o MOV
DS,VARIABLE. 
Ejemplos:
mov  ds,ax
mov  bx,es:[si]
mov  si,offset dato
En el último ejemplo, no se coloca en SI el valor de la variable dato sino su dirección de memoria o
desplazamiento respecto al segmento de datos.
LEA (carga dirección efectiva)
Sintaxis: LEA destino, origen
Transfiere el desplazamiento del operando fuente al operando destino. Otras instrucciones
pueden a continuación utilizar el registro como desplazamiento para acceder a los datos que
constituyen el objetivo. El operando destino no puede ser un registro de segmento. En general,
esta instrucción es equivalente a MOV destino,OFFSET fuente y de hecho los buenos
ensambladores (TASM) la codifican como MOV para economizar un byte de memoria. Sin
embargo, LEA es en algunos casos más potente que MOV al permitir indicar registros de índice y
desplazamiento para calcular el offset:
lea  dx,datos[si]
En el ejemplo de arriba, el valor depositado en DX es el offset de la etiqueta datos más el registro
SI. 
Esa sola instrucción es equivalente a estas dos:
mov  dx,offset datos
add  dx,si
POP (extraer de la pila)
Sintaxis: POP destino
Transfiere el elemento palabra que se encuentra en lo alto de la pila (apuntado por SP) al
operando destino que a de ser tipo palabra, e incrementa en dos el registro SP. La instrucción POP
CS, poco útil, no funciona correctamente en los 286 y superiores.
 
Ejemplos:  
pop ax
pop  pepe
PUSH (introduce en la pila)
Sintaxis: PUSH origen
Decrementa el puntero de pila (SP) en 2 y luego transfiere la palabra especificada en el operando
origen a la cima de la pila. El registro CS aquí sí se puede especificar como origen, al contrario de lo
que afirman algunas publicaciones.
 
Ejemplo:  push  cs
 
CALL (llamada a subrutina)
Sintaxis: CALL destino
Transfiere el control del programa a un procedimiento, salvando previamente en la pila la
dirección de la instrucción siguiente, para poder volver a ella una vez ejecutado el procedimiento.
El procedimiento puede estar en el mismo segmento (tipo NEAR) o en otro segmento (tipo FAR). A
su vez la llamada puede ser directa a una etiqueta (especificando el tipo de llamada NEAR -por
defecto- o FAR) o indirecta, indicando la dirección donde se encuentra el puntero. Según la
llamada sea cercana o lejana, se almacena en la pila una dirección de retorno de 16 bits o dos
palabras de 16 bits indicando en este último caso tanto el offset (IP) como el segmento (CS) a
donde volver.
 
Ejemplos:  
call proc1
dir  dd  0f000e987h
call dword ptr dir
En el segundo ejemplo, la variable dir almacena la dirección a donde saltar. De esta última manera
-conociendo su dirección- puede llamarse también a un vector de interrupción, guardando
previamente los flags en la pila (PUSHF), porque la rutina de interrupción retornará (con IRET en
vez de con RETF) sacándolos.
JMP (salto)
Sintaxis: JMP dirección o JMP SHORT dirección
Transfiere el control incondicionalmente a la dirección indicada en el operando. La bifurcación
puede ser también directa o indirecta como anteriormente vimos, pero además puede ser corta
(tipo SHORT) con un desplazamiento comprendido entre -128 y 127; o larga, con un
desplazamiento de dos bytes con signo. Si se hace un JMP SHORT y no llega el salto (porque está
demasiado alejada esa etiqueta) el ensamblador dará error. Los buenos ensambladores (como
TASM) cuando dan dos pasadas colocan allí donde es posible un salto corto, para economizar
memoria, sin que el programador tenga que ocuparse de poner short. Si el salto de dos bytes, que
permite desplazamientos de 64 Kb en la memoria sigue siendo insuficiente, se puede indicar con
far que es largo (salto a otro segmento).
 
Ejemplos: 
 jmp etiqueta
jmp  far ptr etiqueta
RET / RETF (retorno de subrutina)
Sintaxis: RET [valor] o RETF [valor]
Retorna de un procedimiento extrayendo de la pila la dirección de la siguiente dirección. Se
extraerá el registro de segmento y el desplazamiento en un procedimiento de tipo FAR (dos
palabras) y solo el desplazamiento en un procedimiento NEAR (una palabra). si esta instrucción es
colocada dentro de un bloque PROC-ENDP (como se verá en el siguiente capítulo) el ensamblador
sabe el tipo de retorno que debe hacer, según el procedimiento sea NEAR o FAR. En cualquier
caso, se puede forzar que el retorno sea de tipo FAR con la instrucción RETF. Valor, si es indicado
permite sumar una cantidad valor en bytes a SP antes de retornar, lo que es frecuente en el código
generado por los compiladores para retornar de una función con parámetros. También se puede
retornar de una interrupción con RETF 2, para que devuelva el registro de estado sin restaurarlo
de la pila.
 
INT (interrupción)
Sintaxis: INT n (0 <= n <= 255)
Inicializa un procedimiento de interrupción de un tipo indicado en la instrucción. En la pila se
introduce al llamar a una interrupción la dirección de retorno formada por los registros CS e IP y el
estado de los indicadores. INT 3 es un caso especial de INT, al ensamblarla el ensamblador genera
un sólo byte en vez de los dos habituales; esta interrupción se utiliza para poner puntos de ruptura
en los programas. Véase también IRET y el apartado 1 del capítulo VII.
Ejemplo:  int  21h
 
ADD (suma)
Sintaxis: ADD destino, origen
Suma los operandos origen y destino almacenando el resultado en el operando destino. Se activa
el acarreo si se desborda el registro destino durante la suma.
 
Ejemplos:  
add  ax,bx
add  cl,dh
SUB (resta)
Sintaxis: SUB destino, origen
Resta el operando destino al operando origen, colocando el resultado en el operando destino. Los
operandos pueden tener o no signo, siendo necesario que sean del mismo tipo, byte o palabra.
 
Ejemplos: 
sub  al,bl
sub  dx,dx
MUL (multiplicación sin signo)
Sintaxis: MUL origen  (origen no puede ser operando inmediato)
Multiplica el contenido sin signo del acumulador por el operando origen. Si el operando destino es
un byte el acumulador es AL guardando el resultado en AH y AL, si el contenido de AH es distinto
de 0 activa los indicadores CF y OF. Cuando el operando origen es de longitud palabra el
acumulador es AX quedando el resultado sobre  DX y AX, si el valor de DX es distinto de cero los
indicadores CF y OF se activan.
Ejemplo:  
mul  byte ptr ds:[di]
mul  dx
mul  cl
DIV (división sin signo)
Sintaxis: DIV origen  (origen no puede ser operando inmediato)
Divide, sin considerar el signo, un número contenido en el acumulador y su extensión (AH, AL si el
operando es de tipo byte o DX, AX si el operando es palabra) entre el operando fuente. El cociente
se guarda en AL o AX y el resto en AH o DX según el operando sea byte o palabra respectivamente.
DX o AH deben ser cero antes de la operación. Cuando el cociente es mayor que el resultado
máximo que puede almacenar, cociente y resto quedan indefinidos produciéndose una
interrupción 0. En caso de que las partes más significativas del cociente tengan un valor distinto de
cero se activan los indicadores CF y OF.
Ejemplo:  
div  bl
div  mem_pal

Imagen de Mnemónicos.

Página de investigación 2 (lenguaje ensamblador)

 El único lenguaje que entienden los microcontroladores es el código máquina formado por
ceros y unos del sistema binario.
 El lenguaje ensamblador expresa las instrucciones de una forma más natural al hombre a
la vez que muy cercana al microcontrolador, ya que cada una de esas instrucciones se
corresponde con otra en código máquina.
 El lenguaje ensamblador trabaja con nemónicos, que son grupos de caracteres
alfanuméricos que simbolizan las órdenes o tareas a realizar.
 La traducción de los nemónicos a código máquina entendible por el microcontrolador la
lleva a cabo un programa ensamblador.
 El programa escrito en lenguaje ensamblador se denomina código fuente (*.asm). El
programa ensamblador proporciona a partir de este fichero el correspondiente código
máquina, que suele tener la extensión *.hex
 Página de investigación 3 (lenguaje ensamblador)
El programa ensamblador es el programa que realiza la traducción de un programa escrito en
ensamblador a lenguaje máquina. Esta traducción es directa e inmediata, ya que las instrucciones
en ensamblador no son más que nemotécnicosde las instrucciones máquina que ejecuta
directamente la CPU.

Tipos de ensambladores
Podemos distinguir entre tres tipos de ensambladores:

 Ensambladores básicos. Son de muy bajo nivel, y su tarea consiste básicamente en ofrecer
nombres simbólicos a las distintas instrucciones.
 Ensambladores modulares, o macro ensambladores. Descendientes de los
ensambladores básicos. Hacen todo lo que puede hacer un ensamblador, y además proporcionan
una serie de directivas para definir e invocar macroinstrucciones.
 Ensambladores modulares 32-bits o de alto nivel. Son ensambladores que aparecieron
como respuesta a una nueva arquitectura de procesadores de 32 bits, realizan la misma tarea que
los anteriores, permitiendo también el uso de macros, permiten utilizar estructuras de
programación más complejas propias de los lenguajes de alto nivel.
Traductor de lenguajes de programación
Página de investigación 1 (traductor de lenguajes)
Un traductor es un programa que tiene como entrada un texto escrito en un lenguaje (lenguaje
fuente) y como salida produce un texto escrito en un lenguaje (lenguaje objeto) que preserva el
significado de origen. Ejemplos de traductores son los ensambladores y los compiladores.

 En el proceso de traducción se identifican dos fases principales:

 Fase de análisis

 Fase de Síntesis
Página de investigación 2 (traductor de lenguajes)
Son programas que traducen a su vez los programas fuente escritos en lenguajes de alto nivel a
código máquina.
Los traductores se dividen en:
 Compiladores
 Interpretes

Intérpretes

Un intérprete es un traductor que toma un programa fuente, lo traduce y a continuación lo

ejecuta (dicho programa por medio de la computadora desarrolla una tarea específica).
Un lenguaje que soporte un traductor de tipo intérprete se denomina lenguaje interpretado.
BASIC es el modelo por excelencia interpretado.
Los programas fuente en BASIC se escriben con ayuda de un programa denominado editor que
suele venir incorporado al programa intérprete.

Compiladores

Un compilador es un programa que traduce los programas fuente escritos en lenguajes de alto
nivel a lenguaje máquina.
Los programas escritos en lenguajes de alto nivel (en el editor del lenguaje) se llaman programas
fuente y el programa traducido programa objeto o código objeto. El compilador traduce (sentencia
a sentencia) el programa fuente.
Lenguajes compiladores típicos son: PASCAL, COBOL, C..
Fases de la compilación

La compilación es el proceso de la traducción de programas fuente a programas objeto.

El programa objeto obtenido de la compilación no ha sido traducido normalmente a código
máquina sino a ensamblador. Para conseguir el programa máquina real se debe utilizar un
programa llamado montador o enlazador (linker). El proceso de montaje conduce a un programa
en lenguaje máquina directamente ejecutable:
Por ejemplo:

El proceso de ejecución de un Programa en C++ tiene los siguientes pasos:

1. Escritura del programa fuente con un editor (programa que permite a una computadora
actuar de modo similar a una máquina de escribir electrónica) y guardarlo en un dispositivo de
almacenamiento (un disco).
2. Introducir el programa fuente en memoria.
3. Compilar el programa con el compilador C++.
4. Verificar y corregir errores de compilación (listado de errores).
5. Obtención del programa objeto.
6. El montador obtiene el programa ejecutable.
7. Se ejecuta el programa y si no existen errores, se tendrá la salida del mismo. 

Página de investigación 3 (traductor de lenguajes)

Explicamos el proceso más importante a la hora de hacer funcionar un programa realizado en
lenguajes de alto y medio nivel.

Cuando programamos en lenguajes de alto nivel, lo que estamos haciendo en realidad es el código
fuente de ese programa.

Este código fuente debe ser traducido a binario para que las instrucciones que contienen puedan
ser entendidas y ejecutadas por la máquina.
Para esto existe un programa encargado de realizar la traducción, llamado traductor del lenguaje.

Estos traductores pueden ser de dos tipos:

Ensambladores

Son los encargados de traducir los programas escritos en lenguaje ensamblador a lenguaje
máquina.
Compiladores

Son programas que leen el código fuente y lo traducen o convierten a otro lenguaje. Estos
programas te muestran los errores existentes en el código fuente.

Etapas del proceso de compilación:

1. Edición. Esta fase consiste en escribir el programa empleando algún lenguaje y un editor.

Como resultado nos dará el código fuente de nuestro programa.
2. Compilación. En esta fase se traduce el código fuente obtenido en la fase anterior a código
máquina. Si no se produce ningún error se obtiene el código objeto.
En caso de errores el compilador los mostraría para ayudarnos a corregirlos y se
procedería a su compilación de nuevo, una vez corregidos.
3. Linkado. Esta fase consiste en unir el archivo generado en la fase dos con determinadas
rutinas internas del lenguaje, obteniendo el programa ejecutable.
Existen dos tipos de linkados:

o linkado estático: Los binarios de las librerías se añaden a nuestros binarios

compilados generando el archivo ejecutable.
o Linkado dinámico: no se añaden las librerías a nuestro binario sino que hará que
se carguen en memoria las librerías que en ese momento se necesiten.

Una vez traducido, compilado y linkado el archivo esta listo para su ejecución donde también
podrán surgir problemas y fallos, para los cuales tendríamos que volver a realizar todo el proceso
anteriormente citado, de modo que puedan ser corregidos.

Por este motivo es importante realizar numerosas pruebas en tiempo de ejecución antes de
presentar el programa al cliente.

Otro sistema para la ejecución de nuestro código fuente es mediante el uso de intérpretes (estos
no se encontrarían dentro de los traductores).
Intérpretes

Los intérpretes realizan la traducción y ejecución de forma simultánea, es decir, un intérprete lee
el código fuente y lo va ejecutando al mismo tiempo.

Las diferencias entre un compilador y un intérprete básicamente son:

 Un programa compilado puede funcionar por si solo mientras que un código traducido por
un intérprete no puede funcionar sin éste.
 Un programa traducido por un intérprete puede ser ejecutado en cualquier máquina ya
que, cada vez que se ejecuta el intérprete, tiene que compilarlo.
 Un archivo compilado es mucho más rápido que uno interpretado.
Compilador
Página de investigación 1 (Compilador)
Un compilador es un programa informático que traduce un programa escrito en un lenguaje de
programación a otro lenguaje de programación. Usualmente el segundo lenguaje es lenguaje de
máquina, pero también puede ser un código intermedio (bytecode), o simplemente texto. Este
proceso de traducción se conoce como compilación.

La construcción de un compilador

involucra la división del proceso en una serie de fases que variará con su complejidad.
Generalmente estas fases se agrupan en dos tareas: el análisis del programa fuente y la síntesis del
programa objeto.

 Análisis: Se trata de la comprobación de la corrección del programa fuente, e incluye las

fases correspondientes al Análisis léxico (que consiste en la descomposición del programa
fuente en componentes léxicos), Análisis sintáctico (agrupación de los componentes
léxicos en frases gramaticales) y Análisis semántico (comprobación de la validez semántica
de las sentencias aceptadas en la fase de Análisis Sintáctico).
 Síntesis: Su objetivo es la generación de la salida expresada en el lenguaje objeto y suele
estar formado por una o varias combinaciones de fases de Generación de Código
(normalmente se trata de código intermedio o de código objeto) y de Optimización de
Código (en las que se busca obtener un código lo más eficiente posible).

Alternativamente, las fases descritas para las tareas de análisis y síntesis se pueden agrupar en
Front-end y Back-end:

 Front-end: es la parte que analiza el código fuente, comprueba su validez, genera el árbol
de derivación y rellena los valores de la tabla de símbolos. Esta parte suele ser
independiente de la plataforma o sistema para el cual se vaya a compilar, y está
compuesta por las fases comprendidas entre el Análisis Léxico y la Generación de Código
Intermedio.
 Back-end: es la parte que genera el código máquina, específico de una plataforma, a partir
de los resultados de la fase de análisis, realizada por el Front End.

Esta división permite que el mismo Back End se utilice para generar el código máquina de
varios lenguajes de programación distintos y que el mismo Front End que sirve para analizar el
código fuente de un lenguaje de programación concreto sirva para generar código máquina en
varias plataformas distintas. Suele incluir la generación y optimización del código dependiente de
la máquina.

 
 Diagrama a bloques de la operación
 
de un buen compilador.
Página de investigación 2 (Compilador)
Es un Software que traduce un programa escrito en un lenguaje de programación de alto nivel (C /
C ++, COBOL, etc.) en lenguaje de máquina. Un compilador generalmente genera lenguaje
ensamblador primero y luego traduce el lenguaje ensamblador al lenguaje máquina. Una utilidad
conocida como «enlazador» combina todos los módulos de lenguaje de máquina necesarios en un
programa ejecutable que se puede ejecutar en la computadora.

Un poco de Historia

El término «compilador» fue acuñado a principios de 1950 por Grace Murray Hopper. La
traducción fue vista entonces como la «compilación» de una secuencia de rutinas seleccionadas.

Grace Brewster Murray Hopper fue una científica informática estadounidense y contraalmirante
de la Marina de los Estados Unidos. Una de las primeras programadoras de la computadora
Harvard Mark I, fue una pionera en programación que inventó una de las primeras herramientas
relacionadas con el compilador. Ella popularizó la idea de los lenguajes de programación
independientes de la máquina, lo que condujo al desarrollo de COBOL, un lenguaje de
programación de alto nivel que todavía se usa en la actualidad.

El primer compilador del lenguaje de alto nivel FORTRAN se desarrolló entre 1954 y 1957 en IBM
por un grupo dirigido por John Backus.
Un compilador es uno de los pilares de la programación y de cómo entender la comunicación
entre un lenguaje de alto nivel y una máquina. Al poder conocer el funcionamiento de este paso
intermedio nos permitirá desarrollar y programar de una forma más precisa los lenguajes de alto
nivel.

Tradicionalmente los compiladores generaban código máquina de inferior calidad que el que
podían escribir programadores humanos, pero actualmente los compiladores proporcionan hoy en
día un código máquina de alta calidad pequeño y rápido, haciendo poco atractiva la programación
en ensamblador, programación que en asignaturas como está ya simplemente se menciona por
conocerla, pero no se realiza un estudio para aprender este tipo de programación.

Los programadores de ensamblador siguen teniendo ventaja en cuanto a que disponen de un

mayor conocimiento global del programa que les permite realizar determinadas optimizaciones
del código que resultan muy difíciles para los compiladores

Los compiladores son procesos complejos debido a que tienen varias fases por las que un
programa fuente debe de pasar antes de convertirse en un programa ejecutable, los pasos son los
siguiente

Analizador léxico:

El analizador léxico o lexicográfico (Scanner en inglés) es la primera etapa del proceso de

compilación, el cual se encarga de dividir el programa en Tokens, los cuales, según una tabla de
símbolos definida por el mismo lenguaje.

De esta forma cada token del programa es clasificado según su significado para ser procesados en
la segunda etapa del proceso de compilación.

Analizador sintáctico:

El analizador sintáctico (Parse en inglés), es la segunda fase del proceso de compilación y tiene
como finalidad la generación de un Árbol sintáctico, el cual no es más que una estructura de datos
compleja que permite representar de una forma más simple al programa fuente.
Los compiladores modernos utilizan estructuras de objetos para representa a un programa, de
esta forma existe una clase específica para representa cada posible token de nuestra tabla de
símbolos.

Analizador semántico:

El analizador semántico es el último paso antes de empezar a compilar realmente el código,

prepara el programa para ser compilado. El analizador semántico parte del árbol sintáctico
abstracto y tiene la finalidad de validar los puntos más finos del programa, como por ejemplo,
validar compatibilidad en tipos de datos, que la variable utilizada en una instrucción este
previamente declara o que estén dentro del contexto, si implementamos una interface que todos
los métodos estén definidos, etc.

El analizador semántico es el que analiza que todo el programa tenga un significado exacto y que
este no pueda fallar en tiempo de ejecución.
•
Editores de código o texto
Página de investigación 1 (Editores de código o texto)
Un editor de texto es un programa que permite crear y modificar archivos digitales compuestos
únicamente por texto sin formato, conocidos comúnmente como archivos de texto o texto plano.
El programa lee el archivo e interpreta los bytes leídos según el código de caracteres que usa el
editor. Hoy en día es comúnmente de 7- ó 8-bits en ASCII o UTF-8, rara vez EBCDIC.
Por ejemplo, un editor ASCII de 8 bits que lee el número binario 0110 0001 (decimal 97 ó
hexadecimal 61) en el archivo lo representará en la pantalla por la figura a, que el usuario
reconoce como la letra "a" y ofrecerá al usuario las funciones necesarias para cambiar el número
binario en el archivo.
Los editores de texto son incluidos en el sistema operativo o en algún paquete de
software instalado y se usan cuando se deben crear o modificar archivos de texto como archivos
de configuración, scripts o el código fuente de algún programa.
El archivo creado por un editor de texto incluye por convención en DOS y Microsoft Windows la
extensión ".txt", aunque pueda ser cambiada a cualquier otra con posterioridad.
Tanto Unix como Linux dan al usuario total libertad en la denominación de sus archivos.
Al trasladar archivos de texto de un sistema operativo a otro se debe considerar que existen al
menos dos convenciones diferentes para señalar el término de una línea: Unix y Linux usan
sólo retorno de carro en cambio Microsoft Windows usa al término de cada línea retorno de carro
y salto de línea.
Diferencia entre texto "plano" y archivos de texto con diagramación
Los editores de textos "planos" se distinguen de los procesadores de texto en que se usan para
escribir sólo texto, sin formato y sin imágenes, es decir sin diagramación.
 El texto plano es representado en el editor mostrando todos los caracteres presentes en el
archivo. Los únicos caracteres de formateo son los caracteres de control del respectivo
código de caracteres. En la práctica, éstos son: salto de línea, tabulación horizontal
y retorno de carro. El código de caracteres más usado en el año 2007 es el ASCII.

 Los documentos creados por un procesador de texto generalmente contienen más

caracteres de control para darle al texto un formato o diagramación particular, a menudo
protegidos de ser copiados por una marca registrada como por ejemplo negrilla, cursiva,
columnas, tablas, tipografía, etc. En un comienzo se utilizaron tales formatos sólo
en autoedición, pero hoy se utilizan incluso en el procesador de texto más sencillo.

 Los procesadores de texto pueden en la mayoría de los casos almacenar un texto plano en
un archivo de texto plano, pero se le debe ordenar explícitamente que se desea esa
opción, de otra manera podría guardarlo con algún formato especial.
Página de investigación 2 (Editores de código o texto)
Es un programa informático que permite crear y modificar archivos digitales compuestos por
textos sin formato, conocidos como archivos de texto o “texto plano”. El programa lee un archivo
y ordena los bytes leídos según el código de caracteres que utiliza o usa el editor. Es muy común
de 7 u 8 bits en ASCII o UTF-8, es poco común que aparezca en EBCDIC.
Por ejemplo, un editor ASCII de 8 bits que lee el número binario 0110 0001 (decimal 97 o
hexadecimal 61) en el archivo lo representará en la pantalla por la figura a, que el usuario
reconoce como la letra "a" y ofrecerá al usuario las funciones necesarias para cambiar el número
binario en el archivo.

¿Para qué sirve el editor del texto?:

Los editores de texto están orientados para manejar y crear archivos de texto plano, los cuales
tienen una enorme utilidad dentro de la Informática, sobre todo en el área de la programación, ya
que el código fuente de los programas está hecho en texto plano, así como también los script
interpretados de algunos lenguajes, como JavaScript, Perl, Python, shell, etc.
Con estas aplicaciones, también podemos crear ediciones de archivos byte por byte, como por
ejemplo, cambiar algunas de las propiedades de una imagen o de algún dibujo, para realizar estas
acciones tenemos que conocer el código de caracteres ASCII.
Otra utilidad importante de los editores de texto es, que permiten crear fácilmente listas y bases
de datos que se puede cargar a cualquier gestor, como MySQL, con una facilidad y velocidad
sorprendente y sin tener que cargar aplicaciones especiales para realizar esta tarea.
También, podemos crear notas importantes y realizar descripciones rápidas de cualquier proceso,
las cuales pueden ser leídas desde cualquier equipo, sin importar si cuentan o no con
procesadores de palabras e incluso, se puede crear e-mails con los editores de texto.
¿Qué empresas fabrican los editores de texto y su historia?:

 Microsoft Word: Es el más difundido dentro de los sistemas operativos de Windows y

MacOS X. Puede mezclar en un documento textos, fórmulas matemáticas, imágenes,
gráficos, tablas, hojas de cálculo y muchas otras cosas más. Además, muestra en pantalla
una imagen exacta de lo que se verá una vez impreso, por lo cual, es una aplicación
WYSIWYG (What You See Is What You Get) en español “Lo que ves, es lo que tienes”, lo
que la hace fácil de comprender y utilizar, y los errores se ven de inmediato.

 WordPerfect: Hasta mediados de los noventa fue el más popular. Pertenece a la suite de
Corel, y presenta una gran cantidad de innovadoras características que demuestran que
pretende seguir compitiendo con Microsoft Word.

 WordPad: Está instalado por defecto en el sistema operativo Windows. Es ideal para
quienes necesiten un procesador de texto de forma esporádica, sin buscar un acabado
profesional. El actual WordPad no tiene manejo de tablas, ni corrección de errores
ortográficos, pero si posee reconocimiento de voz y TSF. También permite abrir
documentos de Word (a veces con problemas en sus formatos) pero no permite
guardarlos. En Windows Vista, WordPad ya no admite la posibilidad de leer archivos en
formato Word debido a los problemas de formatos y al rendimiento incorrecto. WordPad
para Windows XP añadió edición de textos multilingües.

 Lotus Word Pro: Fue desarrollado por la empresa Lotus Development fue imitada por
Microsoft Office unos años después de sacarla al mercado es una de las alternativas más
populares a Microsoft Word, y está incluido en el paquete de software de escritorio de
Lotus.

 LibreOffice: LibreOffice es un paquete de software de oficina libre y de código abierto

desarrollado por The Document Foundation, fue un bifurcación de OpenOffice. Se creó
una bifurcación de OpenOffice en 2010. Cuenta con un procesador de texto ( Writer), un
editor de hojas de cálculo (Calc), un gestor de presentaciones (Impress), un gestor de
bases de datos (Base), un editor de gráficos vectoriales (Draw) y un editor de editor de
fórmulas matemáticas (Math).
Página de investigación 3 (Editores de código o texto)
Los editores de texto son programas informáticos que crean y editan archivos digitales en un
formato de texto básico o texto plano, es decir, archivos que no contengan formato de texto
específico.

Los editores de texto, por lo general, son incluidos en el mismo sistema operativo y algunos son
instados por el mismo usuario, según sean sus requerimientos de edición. Algunos son libres y
otros son de pago, todo dependerá de la cantidad de funciones adicionales con las que cuente el
editor, las cuales lo convertirán en una potente herramienta de trabajo.

Usos de los editores de texto

Los editores de texto están orientados a manipular y crear archivos de texto plano, los cuales
tienen una enorme utilidad dentro de la Informática, sobre todo en el área de la programación, ya
que el código fuente de los programas está hecho en texto plano, así como también los scripts
interpretados de algunos lenguajes, como JavaScript, Perl, Python, shell, etc.

Con estas aplicaciones, también podemos crear ediciones de archivos byte por byte, como, por
ejemplo, cambiar algunas de las propiedades de una imagen o de algún dibujo, claro está, que
para realizar estas acciones debemos conocer el código de caracteres ASCII.

Otra utilidad importante de los editores de texto, es que permiten crear fácilmente listas y bases
de datos que podemos cargar a cualquier gestor, como MySQL, con una facilidad y velocidad
sorprendentes y sin tener que cargar aplicaciones especiales para realizar esta tarea.

También, podemos crear notas importantes y realizar descripciones rápidas de cualquier proceso,
las cuales pueden ser leídas desde cualquier equipo, sin importar si cuentan o no con
procesadores de palabras e incluso, podemos crear e-mails con los editores de texto.
Características de los editores de texto

Existen diversos tipos de interfaz de usuario para los editores de texto, algunas muy sencillas y
otras muy completas, que incluso cuentan con diferentes tipos de letras y sintaxis específicas de
algunos softwares de programación. Pero, generalmente, cuentan con funciones para cortar,
pegar, modificar, importar, hacer y deshacer acciones, en esto son muy similares a los
procesadores de palabras.

Algunos editores son del tipo consola y no son muy vistosos a la vista, otros son del tipo visual y
hasta hay unos pocos que nos permiten incluso subir archivos a Internet y operarlos de manera
remota, todo dependerá de los requerimientos del usuario.

Depurador
Página de investigación 1 (depurador)
Los depuradores son herramientas que permiten encontrar y corregir los errores de los programas
(bugs). Suelen ir ligados a los compiladores de forma que el programador pueda comprobar y
visualizar la correcta ejecución de un programa.

Ejemplos de debuggers: Turbo Debugger de Borland y Code View de Microsoft.

El código a ser examinado puede alternativamente estar corriendo en un simulador de conjunto

de instrucciones (ISS), una técnica que permite gran potencia en su capacidad de detenerse
cuando son encontradas condiciones específicas pero será típicamente algo más lento que
ejecutando el código directamente en el apropiado (o el mismo) procesador. Algunas depuradores
ofrecen dos modos de operación - la simulación parcial o completa, para limitar este impacto.
Página de investigación 2 (depurador)
Depurar es el proceso de ubicar y corregir los errores en el código del programa
informático. Depurar un programa es iniciarlo con un código fallado, aislar las fuentes
de todos los problemas y luego arreglarlos.

Un depurador es un programa que ejecuta a otro programa (es decir, su código), lo que
le permitirá ejercitar un nivel de control por encima del código mientras que se ejecuta,
y examinar elementos particulares cuando las cosas salen mal.

Funciones básicas de un depurador

Cuando usted ejecuta un programa que contiene errores, hay varias cosas que querrá hacer
o conocer:

 ¿Qué declaración o expresión estaba ejecutando el programa al momento de un error

fatal?
 Si ocurre un error fatal mientras se ejecuta una función, ¿qué línea del programa
contiene el llamado de esa función?
 ¿Cuáles son los valores de las variables del programa (incluyendo parámetros) en un
punto particular durante la ejecución del programa?
 ¿Cuál es el resultado de la evaluación de una expresión particular en algún punto en el
programa?
 ¿Cuál es la secuencia de declaraciones realmente ejecutadas en un programa?

Estas funciones exigen que usted sea capaz de examinar los datos del programa; obtener
una lista de funciones actualmente en ejecución; establecer puntos de interrupción donde
la ejecución del programa se suspenda para permitir que se analicen sus datos; y revisar las
declaraciones de un programa para ver lo que realmente está sucediendo.

Para dar una idea más clara sobre la operación del código original, casi todos los
depuradores trabajan a un nivel simbólico o de código fuente. En esencia, crean una
apariencia de que usted está ejecutando declaraciones Java o C++ en su programa fuente
en vez del código de máquina al que han sido realmente traducidos.

Cuando depura el código, es generalmente necesario examinar varios elementos de manera

simultánea: el código que se está ejecutando, los registros del hardware en el
microcontrolador, ubicaciones específicas de la memoria y los puntos de interrupción. Así,
usted querrá mostrar múltiples ventanas en un formato GUI.  

Soporte de hardware para depuradores

En ocasiones hay otro programa, el emulador, que simula al propio microcontrolador  de

modo que usted no necesite ningún hardware real, pero para sistemas integrados usted
normalmente ejecuta su código en el kit de desarrollo del microcontrolador o el panel con
vistas a ser producido.
La mayoría de los microcontroladores incluyen características específicas diseñadas para
facilitar la depuración, por ejemplo: soporte de hardware para avanzar una instrucción a la
vez; modos de prueba especiales; y, soporte para puntos de interrupción.

Paquetes de herramientas de software

En muchos casos, los depuradores, junto con otras herramientas de desarrollo de software,
se agrupan en un paquete denominado Entorno de desarrollo integrado o IDE, por sus
siglas en inglés. Muchos fabricantes de microcontroladores suministran IDE para sus
productos, y también están disponibles desde proveedores terceros hasta incluso la
comunidad de fuente abierta.

Los IDE pueden ser productos independientes o (si es de un fabricante) agrupados con
hardware de desarrollo para un microcontrolador específico.
Enlazadores
Página de investigación 1 (enlazadores)
Se podría definir un enlazador como un programa que toma los códigos objetos creados en el
proceso de compilación de un programa, junto con los datos provenientes de subprogramas que
se agrupan en bibliotecas, todo esto con el fin de producir un ejecutable o una biblioteca.

El proceso que lleva a cabo el enlazador comienza a r luego de una revisión sintáctica, semántica y
léxica del código compilado.

El linker u enlazador permite al programador escribir su código en cualquier lenguaje de alto nivel
o si así lo desea en lenguaje de bajo nivel, ya que éste (el enlazador) se encargará de transformarlo
a lenguaje de máquina. Con esto, la tarea del programador se facilita tanto en la codificación como
en el tiempo utilizado para escribir un programa.

FUNCION DE LOS ENLAZADORES

Los enlazadores deben de cumplir con cuatro funciones básicas, a saber:

1. Enlazar al mismo tiempo módulos traducidos independientemente

2. Superposición de procesamiento.
3. Modificación del programa
4. Acceso a las bibliotecas.

La primera función, que es la que se considera la principal, es la que permite crear un único
archivo a partir de varios archivos de código de máquina relocalizable.

Estos archivos pueden haber sido el resultado de varias compilaciones distintas, y uno o varios de
ellos pueden archivos de biblioteca de rutinas proporcionadas por el sistema y disponibles para
cualquier programa que las necesite. Las demás funciones se consideran secundarias, sin embargo,
son necesarias para el funcionamiento que se necesita de un enlazador. Gracias al acceso a
bibliotecas es que podemos utilizar las clases pre compiladas que la mayoría de lenguajes de
programación nos ofrece, también no se permite cambiar por módulos el programa, es decir, que
si se desea cambiar solo un archivo no es necesario compilar y enlazar todo de nuevo,
simplemente es necesario enlazar y compilar el código que deseamos cambiar.

ESTRUCTURA DE LOS ENLAZADORES

Los enlazadores pueden estar estructurados de dos formas diferentes, la primera estructura
corresponde a los enlazadores de una pasada, mientras que la segunda a los enlazadores de dos
pasadas.
Los enlazadores de una pasada durante el procedimiento de enlace almacenan todo o parte del
contenido de los archivos de entrada, en memoria o en el disco y luego en la ejecución leen ese
material.
Por su parte, los enlazadores de dos pasadas, en la primera pasada el enlazador toma todos los
códigos objetos creados en el proceso de compilación y todas librerías necesarias para crear el
ejecutable. En esta primera etapa todos los códigos objetos que van a formar parte del ejecutable
cuentan una serie de segmentos y una tabla de símbolos. La tabla de símbolos contiene símbolos
importados (nombres de rutinas que son llamados desde otro archivos) o exportados (símbolos
que son utilizados en el archivo pero que están definidos en otro).
A todos estos datos de entrada, el enlazador busca el tamaño de sus segmentos, las definiciones y
referencias de todos los símbolos y con esta información crear una única tabla en la que se listan
todos los segmentos definidos en los archivos de entrada. También crea una tabla única de
símbolos que contiene tanto los símbolos importados como los símbolos exportados.

TIPOS DE ENLAZADORES 

Se puede decir que existen dos tipos de enlazadores, a saber, los enlazadores dinámicos y los
enlazadores estáticos

Los enlazadores dinámicos: son aquellos que le permiten a un programa en ejecución agregar,

quitar, remplazar o realojar los módulos de objeto dentro de la dirección de memoria durante su
ejecución.

Los enlazadores estáticos: el proceso de enlace sólo se lleva a cabo una vez cuando se produce
el archivo ejecutable, el cual es cargado directamente en memoria cuando es ejecutado. Como se
puede deducir de lo anteriormente descrito, los programas que usan enlazadores estáticos son
incapaces de cambiar su estructura durante su ejecución.

GENERALIDADES DE LOS ENLAZADORES DINÁMICOS

Como se definió anteriormente los enlazadores dinámicos son aquellos que permiten que un
programa modificado mientras está en ejecución. 

Los enlazadores dinámicos se dividen en dos etapas, la etapa de enlazamiento estática y la etapa
de enlazamiento en tiempo de cargado. Durante la etapa estática las rutinas de las bibliotecas
utilizadas en el ejecutable creado necesitan ser referenciadas, no así definidas, ya que en la
segunda etapa el enlazador se encargará de buscar y cargar todas las rutinas que no están
definidas antes de pasarle el control al procedimiento principal. 

Lo anterior es el proceso que siguen en general todos los enlazadores dinámicos, ahora según el
sistema operativo en el que se esté trabajando la implementación de enlazadores dinámicos va ser
distinta. 
El primer enlazador dinámico que existió fue el ELF dynamic linking introducido por Sun
Microsystems a principio de la década de los 80 el cual se convirtió, en la década de los 90, en
estándar para los sistemas operativos unix y derivados como Linux . Por su parte Microsoft
implementa sus enlazadores dinámicos mediante los dll’s, los cuales tienen prácticamente el
mismo funcionamiento.

Generalidades de los Enlazadores Estáticos

En un principio los enlazadores podían ser sólo de tipo estático, sin embargo como se menciono
anteriormente a partir de la década de los 80’s se logro hacer enlazadores que pudieran ser
ejecutados dinámicamente. Un enlazador estático es aquel que como se mencionó anteriormente
solo se produce una vez y que no permite que el programa cambie mientras está siendo
ejecutado.

Los enlazadores estáticos necesitan además que todos los símbolos globales estén bien definidos y
en el caso de que se deba de hacer un cambio en alguno de los objetos se debe de volver a enlazar
todos los códigos objetos. Por otra parte es más eficiente en ya que es menos complicado de
manejar en memoria que los enlazadores dinámicos, y además de que la tabla de símbolos es
considerablemente más pequeña que los enlazadores dinámicos

Página de investigación 1 (enlazadores)

En programación, cuando se desarrolla un programa, estos pueden utilizar subprogramas y, de
cada uno de ellos, su código objeto debe ser enlazado (unido) al código objeto del programa que
los utilice. Esto se realiza mediante un programa llamado enlazador, montador o linkador en la
fase de enlace.
 IDE
Página de investigación 1 (IDE)
Un entorno de desarrollo integrado (IDE) es un sistema de software para el diseño de aplicaciones
que combina herramientas del desarrollador comunes en una sola interfaz gráfica de usuario
(GUI). Generalmente, un IDE cuenta con las siguientes características:

 Editor de código fuente: editor de texto que ayuda a escribir el código de software con
funciones como el resaltado de la sintaxis con indicaciones visuales, el relleno automático
específico del lenguaje y la comprobación de errores a medida que se escribe el código.
 Automatización de compilación local: herramientas que automatizan tareas sencillas e
iterativas como parte de la creación de una compilación local del software para su uso por parte
del desarrollador, como la compilación del código fuente de la computadora en un código binario,
el empaquetado del código binario y la ejecución de pruebas automatizadas.
 Depurador: programa que sirve para probar otros programas y mostrar la ubicación de un
error en el código original de forma gráfica.

¿Por qué los desarrolladores utilizan los IDE?

Los IDE permiten que los desarrolladores comiencen a programar aplicaciones nuevas con rapidez,
ya que no necesitan establecer ni integrar manualmente varias herramientas como parte del
proceso de configuración. Tampoco es necesario que pasen horas aprendiendo a utilizar
diferentes herramientas por separado, gracias a que todas están representadas en la misma área
de trabajo. Esto resulta muy útil al incorporar desarrolladores nuevos, porque pueden confiar en
un IDE para ponerse al día con los flujos de trabajo y las herramientas estándares de un equipo. De
hecho, la mayoría de las características de los IDE están diseñadas para ahorrar tiempo, como el
relleno inteligente y la generación automatizada del código, lo cual elimina la necesidad de escribir
secuencias enteras de caracteres.

Otras funciones comunes del IDE se encargan de ayudar a los desarrolladores a organizar su flujo
de trabajo y solucionar problemas. Los IDE analizan el código mientras se escribe, así que las fallas
causadas por errores humanos se identifican en tiempo real. Gracias a que hay una sola GUI que
representa todas las herramientas, los desarrolladores pueden ejecutar tareas sin tener que pasar
de una aplicación a otra. El resaltado de sintaxis también es común en la mayoría de los IDE, y
utiliza indicaciones visuales para distinguir la gramática en el editor de texto. Además, algunos IDE
incluyen examinadores de objetos y clases, así como diagramas de jerarquía de clases para ciertos
lenguajes.

Es posible desarrollar aplicaciones sin IDE, o que los desarrolladores básicamente diseñen su
propio IDE integrando varias herramientas de forma manual con los editores de texto ligero como
Vim o Emacs. Para algunos desarrolladores, el beneficio de este enfoque radica en el control y la
personalización extrema que ofrece. Sin embargo, en un contexto empresarial, el tiempo que se
ahorra, la estandarización del entorno y las funciones de automatización de los IDE modernos
normalmente superan las demás consideraciones.
Actualmente, la mayoría de los equipos de desarrollo de las empresas optan por un IDE
preconfigurado que se adecue mejor a sus casos de uso específicos; por lo que la pregunta no es si
conviene adoptar un IDE, sino cuál elegir.

Tipos de IDE conocidos

Hay muchos casos de uso comerciales y técnicos distintos para los IDE, lo cual también significa
que hay muchas opciones de IDE propietarios y open source en el mercado. En general, las
características distintivas más importantes entre los IDE son las siguientes:

 Cantidad de lenguajes compatibles: algunos IDE son compatibles con un solo lenguaje, así que
son mejores para un modelo de programación específico. Por ejemplo, IntelliJ es conocido
principalmente como un IDE de Java. Otros IDE admiten una gran variedad de lenguajes de
manera conjunta, como el IDE Eclipse, que admite Java, XML, Python, entre otros.

 Sistemas operativos compatibles: el sistema operativo de un desarrollador determinará qué

tipos de IDE son viables (salvo que el IDE esté basado en la nube), y estarán aún más limitados
si la aplicación que se desarrolla está diseñada para el usuario final con un sistema operativo
específico (como Android o iOS).

 Características de automatización: si bien la mayoría de los IDE incluyen tres funciones

fundamentales (el editor de texto, la automatización de compilación y el depurador), muchos
admiten funciones adicionales, como la refactorización, la búsqueda de código y las
herramientas de integración e implementación continuas (CI/CD).

 Impacto en el rendimiento del sistema: es importante considerar el footprint del IDE en la

memoria si el desarrollador desea ejecutar otras aplicaciones con uso intensivo de la memoria
al mismo tiempo.

 Complementos y extensiones: algunos IDE incluyen una función para personalizar los flujos de
trabajo de forma que se adapten a las necesidades y preferencias del desarrollador.

IDE para el desarrollo de aplicaciones móviles

La creciente popularidad de las aplicaciones diseñadas para teléfonos inteligentes y tabletas

influye en casi todos los sectores, así que muchas empresas deben desarrollar aplicaciones
móviles, además de las aplicaciones web tradicionales. Uno de los factores clave en el desarrollo
de aplicaciones móviles es la selección de la plataforma. Por ejemplo, si se diseña una aplicación
nueva para su uso en iOS, Android y una página web, será mejor comenzar con un IDE que brinde
soporte en todas las plataformas para varios sistemas operativos.

IDE de nube

Los IDE que se ofrecen como software como servicio (SaaS) basado en la nube brindan varios
beneficios únicos en comparación con los entornos de desarrollo locales. Por un lado, al igual que
con cualquier oferta de SaaS, no es necesario descargar el sistema de software y configurar las
dependencias y los entornos locales, lo cual permite que los desarrolladores comiencen a
contribuir con los proyectos rápidamente. Esto también ofrece un nivel de estandarización en
todos los entornos de los miembros del equipo que permite solucionar el problema típico de que
un elemento funcione bien en una computadora y no en otras. Por otro lado, dado que el entorno
de desarrollo se gestiona de forma centralizada, ningún código reside en la computadora de un
solo desarrollador, lo cual alivia las preocupaciones de seguridad y propiedad intelectual.

El impacto de los procesos en los equipos locales también es diferente. Los procesos como la
ejecución de compilaciones y las pruebas de conjunto de aplicaciones suelen consumir muchos
recursos informáticos. Por eso es probable que los desarrolladores no puedan seguir utilizando las
estaciones de trabajo mientras se ejecuta un proceso. Un IDE de SaaS puede distribuir las tareas
de larga duración sin monopolizar los recursos informáticos de un equipo local. Normalmente, los
IDE de nube no suelen depender de ninguna plataforma, lo cual permite su conexión con
diferentes proveedores de nube.

GUI (interfaz gráfica de usuario)

Una GUI (generalmente pronunciada güi) es una interfaz de usuario gráfica (en lugar de
puramente textual) para una computadora. Al leer esto, usted está mirando la GUI o la interfaz
gráfica de usuario de su navegador web particular. El término entró en existencia porque las
primeras interfaces de usuario interactivas a las computadoras no eran gráficas; estaban
orientadas a texto y teclado, y por lo general consistían en comandos que tenía que recordar y las
respuestas de la computadora que eran infamemente breves. La interfaz de comandos del sistema
operativo DOS (que todavía se puede obtener desde su sistema operativo Windows) es un ejemplo
de la interfaz típica entre usuario y equipo antes de que llegaran las GUI. Un paso intermedio en
las interfaces de usuario entre la interfaz de línea de comandos y la interfaz gráfica de usuario era
la interfaz basada en menús no gráfica, que le permitía interactuar utilizando un ratón en lugar de
tener que escribir comandos del teclado.

Página de investigación 2 (IDE)

Un IDE (Integrated Development Environment ó Entorno de Desarrollo Integrado) es un programa
informático compuesto por un conjunto de herramientas de programación.

Puede dedicarse en exclusiva a un sólo lenguaje de programación o bien, puede ser utilizado para
varios.
Dev C++, un IDE para el lenguaje de programación C++...

WebDevStudio, un IDE en línea para el lenguaje de programación C/C++, Eclipse, NetBeans, Visual
Studio .Net, RAD Studio XE, ...
Un IDE es un entorno de programación que ha sido empaquetado como un programa de
aplicación, es decir, consiste en un editor de código, un compilador, un depurador y un
constructor de interfaz gráfica (GUI). Los IDEs pueden ser aplicaciones por sí solas o pueden ser
parte de aplicaciones existentes. El lenguaje Visual Basic, por ejemplo, puede ser usado dentro de
las aplicaciones de Microsoft Office, lo que hace posible escribir sentencias Visual Basic en forma
de macros para Microsoft Word (VBA).

Los IDE proveen un marco de trabajo amigable para la mayoría de los lenguajes de programación
tales como C++, Python, Java, C#, Delphi, Visual Basic, etc. En algunos lenguajes, un IDE puede
funcionar como un sistema en tiempo de ejecución, en donde se permite utilizar el lenguaje de
programación en forma interactiva, sin necesidad de trabajo orientado a archivos de texto, como
es el caso de Smalltalk u Objective-C.

Es posible que un mismo IDE pueda funcionar con varios lenguajes de programación. Este es el
caso de Eclipse, al que mediante plugins se le puede añadir soporte de lenguajes adicionales.
Bibliografía
https://sites.google.com/site/03fmeautomatismos/home/lenguaje-maquina
https://sites.google.com/site/474introduccionalaprogramacion/evolucion/lenguaje#:~:text=Lengu
aje%20de%20maquina%3A%20El%20lenguaje,comprender%20y%20ejecutar%20el
%20programa.&text=Ejemplo%3A%20Instrucciones%20en%20lenguaje%20de,%2C%201001%2C
%2010001%2C%201110.
https://sites.google.com/site/portafoliocarlosmacallums/unidad-i/lenguajeensamblador
http://paolacazares.blogspot.com/2017/03/ejemplos-de-mnemonicos-en-lenguaje.html
http://ing-radjchv-pmz-estl.blogspot.com/2009/09/14-traductor-y-su-estructura.html#:~:text=Un
%20traductor%20es%20un%20programa,los%20ensambladores%20y%20los%20compiladores.
https://sites.google.com/site/programacionunouaem/unidad-de-competencia-1/traductores-de-
lenguaje
https://desarrolloweb.com/articulos/2387.php
https://www.ictea.com/cs/index.php?rp=%2Fknowledgebase%2F8817%2FiQue-es-un-programa-
compilador.html#:~:text=Un%20compilador%20es%20un%20programa,bytecode)%2C%20o
%20simplemente%20texto.
https://www.europeanvalley.es/noticias/que-es-un-compilador-en-programacion/
https://sites.google.com/site/sedechiapa/home/editores-de-textos
https://sites.google.com/site/informaticaactualysencilla/software/editores-de-texto
https://culturacion.com/para-que-se-usan-los-editores-de-texto/
http://cidecame.uaeh.edu.mx/lcc/mapa/PROYECTO/libro32/127_depuradores.html
https://www.arrow.com/es-mx/research-and-events/articles/debuggers-the-basics
http://enlazadoresuvm.blogspot.com/
http://www.carlospes.com/minidiccionario/enlazador.php
https://www.redhat.com/es/topics/middleware/what-is-ide
https://ajpdsoft.com/modules.php?name=Encyclopedia&op=content&tid=1051