Programa de computadora

Un programa informático es una secuencia o conjunto ^de instrucciones en un lenguaje de programación que un ordenador debe ejecutar . Es un componente del software , que también incluye documentación y otros componentes intangibles. ^[1]

Un programa informático en su forma legible por humanos se denomina código fuente . El código fuente necesita otro programa informático para ejecutarse porque los ordenadores solo pueden ejecutar sus instrucciones de máquina nativas . Por lo tanto, el código fuente puede traducirse a instrucciones de máquina utilizando un compilador escrito para el lenguaje. ( Los programas en lenguaje ensamblador se traducen utilizando un ensamblador ). El archivo resultante se denomina ejecutable . Alternativamente, el código fuente puede ejecutarse dentro de un intérprete escrito para el lenguaje. ^[2]

Si se solicita la ejecución del ejecutable, el sistema operativo lo carga en la memoria e inicia un proceso . ^[3] La unidad central de procesamiento pronto cambiará a este proceso para que pueda buscar, decodificar y luego ejecutar cada instrucción de la máquina. ^[4]

Si se solicita la ejecución del código fuente, el sistema operativo carga el intérprete correspondiente en la memoria e inicia un proceso. A continuación, el intérprete carga el código fuente en la memoria para traducir y ejecutar cada instrucción . La ejecución del código fuente es más lenta que la ejecución de un ejecutable . ^{[5] [b]} Además, el intérprete debe estar instalado en la computadora.

El programa "¡Hola, mundo!" se utiliza para ilustrar la sintaxis básica de un lenguaje . La sintaxis del lenguaje BASIC (1964) se limitó intencionalmente para que el lenguaje fuera fácil de aprender. ^[6] Por ejemplo, las variables no se declaran antes de ser utilizadas. ^[7] Además, las variables se inicializan automáticamente a cero. ^[7] A continuación se muestra un programa de computadora de ejemplo, en Basic, para promediar una lista de números: ^[8]

10 INPUT "¿Cuántos números hay que promediar?" , A 20 FOR I = 1 TO A 30 INPUT "Ingrese el número:" , B 40 LET C = C + B 50 NEXT I 60 LET D = C / A 70 PRINT "El promedio es" , D 80 END                            

Una vez que se aprenden los mecanismos de la programación informática básica, se dispone de lenguajes más sofisticados y potentes para construir grandes sistemas informáticos. ^[9]

Las mejoras en el desarrollo de software son el resultado de mejoras en el hardware de las computadoras . En cada etapa de la historia del hardware, la tarea de la programación de computadoras cambió drásticamente.

En 1837, el telar de Jacquard inspiró a Charles Babbage a intentar construir la máquina analítica . ^[10] Los nombres de los componentes del dispositivo de cálculo fueron tomados de la industria textil. En la industria textil, el hilo se traía del almacén para ser molido. El dispositivo tenía un almacén que consistía en una memoria para almacenar 1.000 números de 50 dígitos decimales cada uno. ^[11] Los números del almacén se transferían al molino para su procesamiento. Se programaba utilizando dos juegos de tarjetas perforadas. Un juego dirigía la operación y el otro introducía las variables. ^{[10] [12]} Sin embargo, las miles de ruedas dentadas y engranajes nunca funcionaron completamente juntos. ^[13]

Ada Lovelace trabajó para Charles Babbage en la creación de una descripción de la máquina analítica (1843). ^[14] La descripción contenía la Nota G, que detallaba por completo un método para calcular números de Bernoulli utilizando la máquina analítica. Algunos historiadores reconocen esta nota como el primer programa informático del mundo . ^[13]

En 1936, Alan Turing presentó la máquina universal de Turing , un dispositivo teórico que puede modelar cada cálculo. ^[15] Es una máquina de estados finitos que tiene una cinta de lectura/escritura infinitamente larga. La máquina puede mover la cinta hacia adelante y hacia atrás, cambiando su contenido mientras realiza un algoritmo . La máquina comienza en el estado inicial, pasa por una secuencia de pasos y se detiene cuando encuentra el estado de detención. ^[16] Todas las computadoras actuales son completas de Turing . ^[17]

El Integrador Numérico Electrónico y Computador (ENIAC) fue construido entre julio de 1943 y otoño de 1945. Era un computador completo de Turing , de propósito general, que usaba 17,468 tubos de vacío para crear los circuitos . En esencia, era una serie de Pascalines conectados entre sí. ^[18] Sus 40 unidades pesaban 30 toneladas, ocupaban 1,800 pies cuadrados (167 m ² ) y consumían $650 por hora ( en la moneda de la década de 1940 ) en electricidad cuando estaban inactivas. ^[18] Tenía 20 acumuladores de base 10. Programar el ENIAC llevaba hasta dos meses. ^[18] Tres mesas de funciones estaban sobre ruedas y necesitaban ser trasladadas a paneles de funciones fijos. Las mesas de funciones se conectaban a los paneles de funciones enchufando cables negros pesados ​​en tableros de conexiones . Cada mesa de funciones tenía 728 perillas giratorias. Programar el ENIAC también implicaba configurar algunos de los 3,000 interruptores. La depuración de un programa llevó una semana. ^[19] Funcionó desde 1947 hasta 1955 en el campo de pruebas de Aberdeen , calculando parámetros de bombas de hidrógeno, prediciendo patrones climáticos y produciendo tablas de tiro para apuntar cañones de artillería. ^[20]

En lugar de enchufar cables y activar interruptores, una computadora con programa almacenado carga sus instrucciones en la memoria de la misma manera que carga sus datos en la memoria. ^[21] Como resultado, la computadora podría programarse rápidamente y realizar cálculos a velocidades muy rápidas. ^[22] Presper Eckert y John Mauchly construyeron el ENIAC. Los dos ingenieros introdujeron el concepto de programa almacenado en un memorando de tres páginas fechado en febrero de 1944. ^[23] Más tarde, en septiembre de 1944, John von Neumann comenzó a trabajar en el proyecto ENIAC. El 30 de junio de 1945, von Neumann publicó el Primer borrador de un informe sobre el EDVAC , que equiparaba las estructuras de la computadora con las estructuras del cerebro humano. ^[22] El diseño se conoció como la arquitectura de von Neumann . La arquitectura se implementó simultáneamente en las construcciones de las computadoras EDVAC y EDSAC en 1949. ^[24]

El IBM System/360 (1964) era una familia de computadoras, cada una con la misma arquitectura de conjunto de instrucciones . El Modelo 20 era el más pequeño y menos costoso. Los clientes podían actualizar y conservar el mismo software de aplicación . ^[25] El Modelo 195 era el más premium. Cada modelo System/360 presentaba multiprogramación ^[25] —tener múltiples procesos en memoria a la vez. Cuando un proceso estaba esperando entrada/salida , otro podía computar.

IBM planeó que cada modelo se programara utilizando PL/1 . ^[26] Se formó un comité que incluía programadores de COBOL , Fortran y ALGOL . El propósito era desarrollar un lenguaje que fuera completo, fácil de usar, extensible y que reemplazara a Cobol y Fortran. ^[26] El resultado fue un lenguaje grande y complejo que tardaba mucho tiempo en compilarse . ^[27]

Las computadoras fabricadas hasta la década de 1970 tenían interruptores en el panel frontal para la programación manual. ^[28] El programa de computadora se escribía en papel para su consulta. Una instrucción se representaba mediante una configuración de opciones de encendido y apagado. Después de establecer la configuración, se presionaba un botón de ejecución. Este proceso se repetía a continuación. Los programas de computadora también se ingresaban automáticamente a través de cinta de papel , tarjetas perforadas o cinta magnética . Después de cargar el medio, se establecía la dirección de inicio a través de interruptores y se presionaba el botón de ejecución. ^[28]

Un hito importante en el desarrollo de software fue la invención del circuito de integración a muy gran escala (VLSI) (1964). ^[29] Después de la Segunda Guerra Mundial , la tecnología basada en tubos fue reemplazada por transistores de contacto puntual (1947) y transistores de unión bipolar (finales de la década de 1950) montados en una placa de circuito . ^[29] Durante la década de 1960 , la industria aeroespacial reemplazó la placa de circuito por un chip de circuito integrado . ^[29]

Robert Noyce , cofundador de Fairchild Semiconductor (1957) e Intel (1968), logró una mejora tecnológica para refinar la producción de transistores de efecto de campo (1963). ^[30] El objetivo es alterar la resistividad eléctrica y la conductividad de una unión semiconductora . Primero, los minerales de silicato naturales se convierten en varillas de polisilicio utilizando el proceso Siemens . ^[31] Luego, el proceso Czochralski convierte las varillas en un silicio monocristalino , cristal boule . ^[32] Luego, el cristal se corta en rodajas finas para formar un sustrato de oblea . Luego, el proceso planar de fotolitografía integra transistores unipolares, capacitores , diodos y resistencias en la oblea para construir una matriz de transistores de metal-óxido-semiconductor (MOS). ^{[33] [34]} El transistor MOS es el componente principal en los chips de circuitos integrados . ^[30]

Originalmente, los chips de circuitos integrados tenían su función establecida durante la fabricación. Durante la década de 1960, el control del flujo eléctrico migró a la programación de una matriz de memoria de solo lectura (ROM). La matriz se parecía a una matriz bidimensional de fusibles. ^[29] El proceso para incrustar instrucciones en la matriz consistía en quemar las conexiones innecesarias. ^[29] Había tantas conexiones que los programadores de firmware escribieron un programa de computadora en otro chip para supervisar la quema. ^[29] La tecnología se conoció como ROM programable . En 1971, Intel instaló el programa de computadora en el chip y lo denominó microprocesador Intel 4004. ^[35]

En la actualidad, los términos microprocesador y unidad central de procesamiento (CPU) se utilizan indistintamente. Sin embargo, las CPU son anteriores a los microprocesadores. Por ejemplo, el IBM System/360 (1964) tenía una CPU hecha de placas de circuitos que contenían componentes discretos sobre sustratos cerámicos . ^[36]

El Intel 4004 (1971) fue un microprocesador de 4 bits diseñado para ejecutar la calculadora Busicom . Cinco meses después de su lanzamiento, Intel lanzó el Intel 8008 , un microprocesador de 8 bits. Bill Pentz dirigió un equipo en Sacramento State para construir el primer microordenador que utilizaba el Intel 8008: el Sac State 8008 (1972). ^[37] Su propósito era almacenar registros médicos de pacientes. El ordenador admitía un sistema operativo de disco para ejecutar una unidad de disco duro Memorex de 3 megabytes . ^[29] Tenía una pantalla a color y un teclado que estaban empaquetados en una única consola. El sistema operativo de disco se programó utilizando el lenguaje ensamblador básico (BAL) de IBM . La aplicación de registros médicos se programó utilizando un intérprete BASIC . ^[29] Sin embargo, el ordenador era un callejón sin salida evolutivo porque era extremadamente caro. Además, se construyó en un laboratorio de una universidad pública para un propósito específico. ^[37] Sin embargo, el proyecto contribuyó al desarrollo del conjunto de instrucciones Intel 8080 (1974) . ^[29]

En 1978, el entorno de desarrollo de software moderno comenzó cuando Intel actualizó el Intel 8080 al Intel 8086. Intel simplificó el Intel 8086 para fabricar el más económico Intel 8088. [ ^38] IBM adoptó el Intel 8088 cuando entró en el mercado de las computadoras personales (1981). A medida que la demanda de computadoras personales por parte de los consumidores aumentó, también lo hizo el desarrollo de microprocesadores de Intel. La sucesión de desarrollo se conoce como la serie x86 . El lenguaje ensamblador x86 es una familia de instrucciones de máquina compatibles con versiones anteriores . Las instrucciones de máquina creadas en microprocesadores anteriores se conservaron a lo largo de las actualizaciones de microprocesadores. Esto permitió a los consumidores comprar nuevas computadoras sin tener que comprar nuevo software de aplicación . Las principales categorías de instrucciones son: ^[c]

• Instrucciones de memoria para configurar y acceder a números y cadenas en la memoria de acceso aleatorio .
• Instrucciones de unidad lógica aritmética (ALU) de números enteros para realizar las operaciones aritméticas primarias con números enteros .
• Instrucciones ALU de punto flotante para realizar las operaciones aritméticas primarias en números reales .
• Instrucciones de la pila de llamadas para insertar y extraer palabras necesarias para asignar memoria e interactuar con funciones .
• Instrucciones de instrucción única, datos múltiples (SIMD) ^[d] para aumentar la velocidad cuando hay varios procesadores disponibles para realizar el mismo algoritmo en una matriz de datos .

Los circuitos VLSI permitieron que el entorno de programación avanzara desde una terminal de computadora (hasta la década de 1990) a una computadora con interfaz gráfica de usuario (GUI). Las terminales de computadora limitaban a los programadores a un solo shell que se ejecutaba en un entorno de línea de comandos . Durante la década de 1970, la edición de código fuente en pantalla completa se hizo posible a través de una interfaz de usuario basada en texto . Independientemente de la tecnología disponible, el objetivo es programar en un lenguaje de programación .

Las características del lenguaje de programación existen para proporcionar bloques de construcción que se puedan combinar para expresar ideales de programación. ^[39] Idealmente, un lenguaje de programación debería: ^[39]

• Expresar ideas directamente en el código.
• Expresar ideas independientes de forma independiente.
• Expresar relaciones entre ideas directamente en el código.
• combinar ideas libremente
• Combine ideas sólo cuando las combinaciones tengan sentido.
• Expresar ideas simples de forma sencilla.

El estilo de programación de un lenguaje de programación para proporcionar estos bloques de construcción se puede clasificar en paradigmas de programación . ^[40] Por ejemplo, diferentes paradigmas pueden diferenciar: ^[40]

• lenguajes procedimentales , lenguajes funcionales y lenguajes lógicos .
• diferentes niveles de abstracción de datos .
• diferentes niveles de jerarquía de clases .
• diferentes niveles de tipos de datos de entrada , como en los tipos contenedores y la programación genérica .

Cada uno de estos estilos de programación ha contribuido a la síntesis de diferentes lenguajes de programación . ^[40]

Un lenguaje de programación es un conjunto de palabras clave , símbolos , identificadores y reglas mediante los cuales los programadores pueden comunicar instrucciones a la computadora. ^[41] Siguen un conjunto de reglas llamadas sintaxis . ^[41]

• Las palabras clave son palabras reservadas para formar declaraciones y enunciados .
• Los símbolos son caracteres para formar operaciones , asignaciones , control de flujo y delimitadores .
• Los identificadores son palabras creadas por los programadores para formar constantes , nombres de variables , nombres de estructuras y nombres de funciones .
• Las reglas de sintaxis se definen en la forma Backus-Naur .

Los lenguajes de programación obtienen su base de los lenguajes formales . ^[42] El propósito de definir una solución en términos de su lenguaje formal es generar un algoritmo para resolver el problema subyacente. ^[42] Un algoritmo es una secuencia de instrucciones simples que resuelven un problema. ^[43]

La evolución de los lenguajes de programación comenzó cuando el EDSAC (1949) utilizó el primer programa informático almacenado en su arquitectura von Neumann . ^[44] La programación del EDSAC estaba en la primera generación de lenguajes de programación .

• La primera generación de lenguaje de programación es el lenguaje de máquina . ^[45] El lenguaje de máquina requiere que el programador ingrese instrucciones utilizando números de instrucción llamados código de máquina . Por ejemplo, la operación ADD en el PDP-11 tiene el número de instrucción 24576. ^[46]

• La segunda generación de lenguaje de programación es el lenguaje ensamblador . ^[45] El lenguaje ensamblador permite al programador utilizar instrucciones mnemotécnicas en lugar de recordar números de instrucción. Un ensamblador traduce cada mnemotécnico del lenguaje ensamblador a su número de lenguaje de máquina. Por ejemplo, en el PDP-11, la operación 24576 puede referenciarse como ADD en el código fuente. ^[46] Las cuatro operaciones aritméticas básicas tienen instrucciones de ensamblaje como ADD, SUB, MUL y DIV. ^[46] Las computadoras también tienen instrucciones como DW (Define Word ) para reservar celdas de memoria . Luego, la instrucción MOV puede copiar números enteros entre registros y memoria.

• La estructura básica de una declaración en lenguaje ensamblador es una etiqueta, una operación , un operando y un comentario. ^[47]

• Las etiquetas permiten al programador trabajar con nombres de variables . El ensamblador traducirá posteriormente las etiquetas en direcciones de memoria física .
• Las operaciones permiten al programador trabajar con mnemónicos. El ensamblador traducirá posteriormente los mnemónicos en números de instrucciones.
• Los operandos le dicen al ensamblador qué datos procesará la operación.
• Los comentarios permiten al programador articular una narrativa porque las instrucciones por sí solas son vagas.

La característica clave de un programa en lenguaje ensamblador es que forma una correspondencia uno a uno con su destino en lenguaje máquina correspondiente. ^[48]

• La tercera generación de lenguajes de programación utiliza compiladores e intérpretes para ejecutar programas informáticos. La característica distintiva de un lenguaje de tercera generación es su independencia de un hardware particular. ^[49] Los primeros lenguajes incluyen Fortran (1958), COBOL (1959), ALGOL (1960) y BASIC (1964). ^[45] En 1973, el lenguaje de programación C surgió como un lenguaje de alto nivel que producía instrucciones de lenguaje de máquina eficientes. ^[50] Mientras que los lenguajes de tercera generación históricamente generaban muchas instrucciones de máquina para cada declaración, ^[51] C tiene declaraciones que pueden generar una sola instrucción de máquina. ^[e] Además, un compilador optimizador podría anular al programador y producir menos instrucciones de máquina que declaraciones. Hoy en día, un paradigma completo de lenguajes llena el espectro imperativo de tercera generación .

• La cuarta generación de lenguajes de programación pone énfasis en los resultados de salida deseados, en lugar de en cómo deben construirse las instrucciones de programación. ^[45] Los lenguajes declarativos intentan limitar los efectos secundarios y permiten a los programadores escribir código con relativamente pocos errores. ^[45] Un lenguaje popular de cuarta generación se llama lenguaje de consulta estructurado (SQL). ^{[45] Los desarrolladores} de bases de datos ya no necesitan procesar cada registro de la base de datos de uno en uno. Además, una simple instrucción puede generar registros de salida sin tener que entender cómo se recuperan.

Los lenguajes imperativos especifican un algoritmo secuencial utilizando declaraciones , expresiones y afirmaciones : ^[52]

• Una declaración introduce un nombre de variable en el programa de computadora y lo asigna a un tipo de datos ^[53] – por ejemplo:var x: integer;
• Una expresión produce un valor, por ejemplo: 2 + 2produce 4
• Una declaración podría asignar una expresión a una variable o usar el valor de una variable para alterar el flujo de control del programa , por ejemplo:x := 2 + 2; if x = 4 then do_something();

FORTRAN (1958) se presentó como "El sistema de traducción de fórmulas matemáticas de IBM". Fue diseñado para cálculos científicos, sin funciones de manejo de cadenas . Junto con declaraciones , expresiones y sentencias , admitía:

• matrices .
• subrutinas .
• bucles "do" .

Tuvo éxito porque:

• Los costos de programación y depuración estaban por debajo de los costos de funcionamiento de la computadora.
• Fue apoyado por IBM.
• Las aplicaciones en ese momento eran científicas. ^[54]

Sin embargo, otros proveedores que no eran IBM también escribieron compiladores Fortran, pero con una sintaxis que probablemente no sería compatible con el compilador de IBM. ^[54] El Instituto Nacional Estadounidense de Estándares (ANSI) desarrolló el primer estándar Fortran en 1966. En 1978, Fortran 77 se convirtió en el estándar hasta 1991. Fortran 90 admite:

• registros .
• punteros a matrices.

COBOL (1959) significa "lenguaje común orientado a los negocios". Fortran manipulaba símbolos. Pronto se comprendió que los símbolos no tenían por qué ser números, por lo que se introdujeron las cadenas . ^[55] El Departamento de Defensa de los EE. UU. influyó en el desarrollo de COBOL, y Grace Hopper fue una de las principales contribuyentes. Las instrucciones eran similares al inglés y verbosas. El objetivo era diseñar un lenguaje para que los gerentes pudieran leer los programas. Sin embargo, la falta de instrucciones estructuradas dificultó este objetivo. ^[56]

El desarrollo de COBOL estuvo muy controlado, por lo que no surgieron dialectos que requirieran estándares ANSI. Como consecuencia, no se modificó durante 15 años hasta 1974. La versión de los años 1990 sí introdujo cambios importantes, como la programación orientada a objetos . ^[56]

ALGOL (1960) significa "lenguaje ALGOrítmico". Tuvo una profunda influencia en el diseño de lenguajes de programación. ^[57] Surgió de un comité de expertos en lenguajes de programación europeos y estadounidenses, utilizaba notación matemática estándar y tenía un diseño legible y estructurado. Algol fue el primero en definir su sintaxis utilizando la forma Backus–Naur . ^[57] Esto condujo a los compiladores dirigidos por sintaxis . Añadió características como:

• estructura de bloque , donde las variables eran locales a su bloque.
• matrices con límites variables.
• bucles "for" .
• funciones .
• recursión . ^[57]

Los descendientes directos de Algol incluyen Pascal , Modula-2 , Ada , Delphi y Oberon en una rama. En otra rama, los descendientes incluyen C , C++ y Java . ^[57]

BASIC (1964) significa "Código de instrucción simbólica multiuso para principiantes". Fue desarrollado en el Dartmouth College para que lo aprendieran todos sus estudiantes. ^[8] Si un estudiante no pasaba a un lenguaje más potente, seguiría recordando Basic. ^[8] Se instaló un intérprete de Basic en los microordenadores fabricados a finales de los años 70. A medida que la industria de los microordenadores crecía, también lo hacía el lenguaje. ^[8]

Basic fue pionero en la sesión interactiva . ^[8] Ofrecía comandos del sistema operativo dentro de su entorno:

• El comando 'nuevo' creó una pizarra vacía.
• Declaraciones evaluadas inmediatamente.
• Las declaraciones se pueden programar precediéndolas con números de línea. ^[f]
• El comando 'list' mostró el programa.
• El comando 'ejecutar' ejecutó el programa.

Sin embargo, la sintaxis básica era demasiado simple para programas grandes. ^[8] Los dialectos más recientes añadieron estructura y extensiones orientadas a objetos. El Visual Basic de Microsoft todavía se utiliza ampliamente y produce una interfaz gráfica de usuario . ^[7]

El lenguaje de programación C (1973) recibió su nombre porque el lenguaje BCPL fue reemplazado por B , y AT&T Bell Labs llamó a la siguiente versión "C". Su propósito era escribir el sistema operativo UNIX . ^[50] C es un lenguaje relativamente pequeño, lo que facilita la escritura de compiladores. Su crecimiento reflejó el crecimiento del hardware en la década de 1980. ^[50] Su crecimiento también se debió a que tiene las facilidades del lenguaje ensamblador , pero utiliza una sintaxis de alto nivel . Agregó características avanzadas como:

• ensamblador en línea .
• Aritmética sobre punteros.
• punteros a funciones.
• operaciones de bits.
• combinando libremente operadores complejos . ^[50]

C permite al programador controlar qué región de la memoria se almacenará. Las variables globales y estáticas requieren la menor cantidad de ciclos de reloj para almacenarse. La pila se utiliza automáticamente para las declaraciones de variables estándar . La memoria del montón se devuelve a una variable de puntero desde la malloc()función.

• La región de datos globales y estáticos se encuentra justo encima de la región de programa . (La región de programa se denomina técnicamente región de texto . Es donde se almacenan las instrucciones de la máquina).

• La región de datos globales y estáticos son técnicamente dos regiones. ^[58] Una región se denomina segmento de datos inicializados , donde se almacenan las variables declaradas con valores predeterminados. La otra región se denomina bloque iniciado por segmento , donde se almacenan las variables declaradas sin valores predeterminados.
• Las direcciones de las variables almacenadas en la región de datos globales y estáticos se configuran en el momento de la compilación y conservan sus valores durante toda la vida del proceso.

• La región global y estática almacena las variables globales que se declaran encima de (fuera de) la main()función. ^[59] Las variables globales son visibles para main()todas las demás funciones en el código fuente.

Por otra parte, las declaraciones de variables dentro de main(), otras funciones o dentro de { } delimitadores de bloques son variables locales . Las variables locales también incluyen variables de parámetros formales . Las variables de parámetros se encierran dentro de los paréntesis de una definición de función. ^[60] Los parámetros proporcionan una interfaz a la función.

• Las variables locales declaradas mediante el staticprefijo también se almacenan en la región de datos globales y estáticos . ^[58] A diferencia de las variables globales, las variables estáticas solo son visibles dentro de la función o el bloque. Las variables estáticas siempre conservan su valor. Un ejemplo de uso sería la función int increment_counter(){static int counter = 0; counter++; return counter;}^[g]

• La región de pila es un bloque contiguo de memoria ubicado cerca de la dirección de memoria superior. ^[61] Las variables colocadas en la pila se rellenan de arriba a abajo. ^{[h] [61]} Un puntero de pila es un registro de propósito especial que realiza un seguimiento de la última dirección de memoria rellenada. ^[61] Las variables se colocan en la pila a través de la instrucción PUSH del lenguaje ensamblador . Por lo tanto, las direcciones de estas variables se establecen durante el tiempo de ejecución . El método para que las variables de pila pierdan su alcance es a través de la instrucción POP.

• Las variables locales declaradas sin staticprefijo, incluidas las variables de parámetros formales, ^[62] se denominan variables automáticas ^[59] y se almacenan en la pila. ^[58] Son visibles dentro de la función o bloque y pierden su alcance al salir de la función o bloque.

• La región del montón se encuentra debajo de la pila. ^[58] Se llena de abajo hacia arriba. El sistema operativo administra el montón usando un puntero de montón y una lista de bloques de memoria asignados. ^[63] Al igual que la pila, las direcciones de las variables del montón se establecen durante el tiempo de ejecución. Se produce un error de falta de memoria cuando el puntero del montón y el puntero de la pila se encuentran.

• C proporciona la malloc()función de biblioteca para asignar memoria de montón. ^{[i] [64]} Llenar el montón con datos es una función de copia adicional. ^[j] Las variables almacenadas en el montón se pasan de manera económica a las funciones mediante punteros. Sin punteros, todo el bloque de datos tendría que pasarse a la función a través de la pila.

En la década de 1970, los ingenieros de software necesitaban soporte de lenguaje para dividir proyectos grandes en módulos . ^[65] Una característica obvia era descomponer proyectos grandes físicamente en archivos separados . Una característica menos obvia era descomponer proyectos grandes lógicamente en tipos de datos abstractos . ^[65] En ese momento, los lenguajes admitían tipos de datos concretos (escalares) como números enteros , números de punto flotante y cadenas de caracteres . Los tipos de datos abstractos son estructuras de tipos de datos concretos, con un nuevo nombre asignado. Por ejemplo, una lista de números enteros podría llamarse integer_list.

En la jerga orientada a objetos, los tipos de datos abstractos se denominan clases . Sin embargo, una clase es solo una definición; no se le asigna memoria. Cuando se le asigna memoria a una clase y se la vincula a un identificador , se la denomina objeto . ^[66]

Los lenguajes imperativos orientados a objetos se desarrollaron combinando la necesidad de clases y la necesidad de una programación funcional segura . ^[67] Una función, en un lenguaje orientado a objetos, se asigna a una clase. Una función asignada se denomina entonces método , función miembro u operación . La programación orientada a objetos consiste en ejecutar operaciones sobre objetos . ^[68]

Los lenguajes orientados a objetos admiten una sintaxis para modelar relaciones de subconjuntos/superconjuntos . En la teoría de conjuntos , un elemento de un subconjunto hereda todos los atributos contenidos en el superconjunto. Por ejemplo, un estudiante es una persona. Por lo tanto, el conjunto de estudiantes es un subconjunto del conjunto de personas. Como resultado, los estudiantes heredan todos los atributos comunes a todas las personas. Además, los estudiantes tienen atributos únicos que otras personas no tienen. Los lenguajes orientados a objetos modelan relaciones de subconjuntos/superconjuntos utilizando la herencia . ^[69] La programación orientada a objetos se convirtió en el paradigma de lenguaje dominante a fines de la década de 1990. ^[65]

C++ (1985) se llamó originalmente "C con clases". ^[70] Fue diseñado para expandir las capacidades de C agregando las facilidades orientadas a objetos del lenguaje Simula . ^[71]

Un módulo orientado a objetos se compone de dos archivos. El archivo de definiciones se denomina archivo de encabezado . A continuación, se muestra un archivo de encabezado de C++ para la clase GRADE en una aplicación escolar sencilla:

// grado.h // -------// Se utiliza para permitir que varios archivos de origen incluyan este archivo de encabezado sin errores de duplicación. // ---------------------------------------------- #ifndef GRADE_H #define GRADE_Hclase GRADE { public : // Esta es la operación del constructor. // ---------------------------------- GRADE ( const char letter );           // Esta es una variable de clase. // ------------------------- char letra ;    // Esta es una operación miembro. // --------------------------- int grade_numeric ( const char letter );        // Esta es una variable de clase. // ------------------------- int numérico ; }; #endif   

Una operación constructora es una función con el mismo nombre que el nombre de la clase. ^[72] Se ejecuta cuando la operación que llama ejecuta la newdeclaración.

El otro archivo de un módulo es el archivo fuente . A continuación, se muestra un archivo fuente de C++ para la clase GRADE en una aplicación escolar sencilla:

// calificación.cpp // --------- #include "calificación.h" GRADE :: GRADE ( const char letter ) { // Hacer referencia al objeto usando la palabra clave 'this'. // ---------------------------------------------- this -> letter = letter ;          // Esto es cohesión temporal // ------------------------- this -> numeric = grade_numeric ( letter ); }      int CALIFICACIÓN :: calificación_numérica ( const char letra ) { if ( ( letra == 'A' || letra == 'a' ) ) return 4 ; else if ( ( letra == 'B' || letra == 'b' ) ) return 3 ; else if ( ( letra == 'C' || letra == 'c' ) ) return 2 ; else if ( ( letra == 'D' || letra == 'd' ) ) return 1 ; else if ( ( letra == 'F' || letra == 'f' ) ) return 0 ; else return -1 ; }                                                                                  

Aquí hay un archivo de encabezado C++ para la clase PERSONA en una aplicación escolar simple:

// persona.h // -------- #ifndef PERSONA_H #define PERSONA_Hclase PERSONA { público : PERSONA ( const char * nombre ); const char * nombre ; }; #endif           

Aquí hay un archivo fuente de C++ para la clase PERSONA en una aplicación escolar simple:

// persona.cpp // ---------- #include "persona.h" PERSONA :: PERSONA ( const char * nombre ) { this -> nombre = nombre ; }        

Aquí hay un archivo de encabezado C++ para la clase ESTUDIANTE en una aplicación escolar simple:

// estudiante.h // --------- #ifndef ESTUDIANTE_H #define ESTUDIANTE_H#include "persona.h" #include "calificación.h"  // Un ESTUDIANTE es un subconjunto de PERSONA. // -------------------------------- class ESTUDIANTE : public PERSONA { public : ESTUDIANTE ( const char * nombre ); CALIFICACIÓN * calificación ; }; #endif            

Aquí hay un archivo fuente de C++ para la clase ESTUDIANTE en una aplicación escolar simple:

// estudiante.cpp // ----------- #include "estudiante.h" #include "persona.h"  ESTUDIANTE :: ESTUDIANTE ( const char * nombre ) : // Ejecuta el constructor de la superclase PERSONA. // ------------------------------------------------- PERSONA ( nombre ) { // No hay nada más que hacer. // ------------------- }            

A continuación se muestra un programa de controlador para demostración:

// estudiante_dvr.cpp // --------------- #include <iostream> #include "estudiante.h"  int main ( void ) { ESTUDIANTE * estudiante = new ESTUDIANTE ( "El Estudiante" ); estudiante -> calificación = new CALIFICACIÓN ( 'a' );                 std :: cout // Observe que el estudiante hereda el nombre de PERSONA << estudiante -> nombre << ": Calificación numérica = " << estudiante -> calificación -> numérico << " \n " ; return 0 ; }          

Aquí hay un makefile para compilar todo:

# makefile # -------- todos : student_dvr limpio :  rm  student_dvr  *.oestudiante_dvr : estudiante_dvr . cpp grado . o estudiante . o persona . o c++ estudiante_dvr.cpp grado.o estudiante.o persona.o -o estudiante_dvr           grado.o : grado .cpp grado .h c ++ -c grado.cpp​     estudiante.o : estudiante . cpp estudiante . h c++ -c estudiante. cpp     persona.o : persona . cpp persona . h c++ -c persona.cpp     

Los lenguajes imperativos tienen una crítica importante: asignar una expresión a una variable no local puede producir un efecto secundario no deseado . ^[73] Los lenguajes declarativos generalmente omiten la declaración de asignación y el flujo de control. Describen qué cálculo se debe realizar y no cómo calcularlo. Dos amplias categorías de lenguajes declarativos son los lenguajes funcionales y los lenguajes lógicos .

El principio detrás de un lenguaje funcional es utilizar el cálculo lambda como guía para una semántica bien definida . ^[74] En matemáticas, una función es una regla que asigna elementos de una expresión a un rango de valores . Considere la función:

times_10(x) = 10 * x

La expresión 10 * x se asigna mediante la función times_10()a un rango de valores . Un valor es 20. Esto ocurre cuando x es 2. Por lo tanto, la aplicación de la función se escribe matemáticamente como:

times_10(2) = 20

Un compilador de lenguaje funcional no almacenará este valor en una variable, sino que lo colocará en la pila de la computadora antes de volver a poner el contador del programa en la función que lo llamó. La función que lo llamó luego extraerá el valor de la pila. ^[75]

Los lenguajes imperativos admiten funciones. Por lo tanto, la programación funcional se puede lograr en un lenguaje imperativo, si el programador utiliza disciplina. Sin embargo, un lenguaje funcional impondrá esta disciplina al programador a través de su sintaxis. Los lenguajes funcionales tienen una sintaxis diseñada para enfatizar el qué . ^[76]

Un programa funcional se desarrolla con un conjunto de funciones primitivas seguidas de una única función controladora. ^[73] Considere el fragmento :

function max( a, b ){/* code omitted */}

function min( a, b ){/* code omitted */}

function range( a, b, c ) {

return max( a, max( b, c ) ) - min( a, min( b, c ) );

}

Las primitivas son max()y min(). La función controladora es range(). Ejecutando:

put( range( 10, 4, 7) );salida 6.

Los lenguajes funcionales se utilizan en la investigación informática para explorar nuevas características del lenguaje. ^[77] Además, su falta de efectos secundarios los ha hecho populares en la programación paralela y la programación concurrente . ^[78] Sin embargo, los desarrolladores de aplicaciones prefieren las características orientadas a objetos de los lenguajes imperativos . ^[78]

Lisp (1958) significa "LISt Processor" (Procesador de listas). ^[79] Está diseñado para procesar listas . Se forma una estructura completa de los datos mediante la construcción de listas de listas. En la memoria, se construye una estructura de datos en forma de árbol . Internamente, la estructura en forma de árbol se presta muy bien para funciones recursivas . ^[80] La sintaxis para construir un árbol es encerrar los elementos separados por espacios entre paréntesis. La siguiente es una lista de tres elementos. Los dos primeros elementos son en sí mismos listas de dos elementos:

((A B) (HELLO WORLD) 94)

Lisp tiene funciones para extraer y reconstruir elementos. ^[81] La función head()devuelve una lista que contiene el primer elemento de la lista. La función tail()devuelve una lista que contiene todo excepto el primer elemento. La función cons()devuelve una lista que es la concatenación de otras listas. Por lo tanto, la siguiente expresión devolverá la lista x:

cons(head(x), tail(x))

Una desventaja de Lisp es que cuando se anidan muchas funciones, los paréntesis pueden parecer confusos. ^[76] Los entornos Lisp modernos ayudan a garantizar la coincidencia de paréntesis. Como acotación al margen, Lisp admite las operaciones de lenguaje imperativo de la declaración de asignación y los bucles goto. ^[82] Además, Lisp no se preocupa por el tipo de datos de los elementos en tiempo de compilación. ^[83] En cambio, asigna (y puede reasignar) los tipos de datos en tiempo de ejecución . La asignación del tipo de datos en tiempo de ejecución se llama enlace dinámico . ^[84] Mientras que el enlace dinámico aumenta la flexibilidad del lenguaje, los errores de programación pueden persistir hasta el final del proceso de desarrollo de software . ^[84]

Escribir programas Lisp grandes, fiables y legibles requiere previsión. Si se planifica adecuadamente, el programa puede ser mucho más corto que un programa equivalente en lenguaje imperativo . ^[76] Lisp se utiliza ampliamente en inteligencia artificial . Sin embargo, su uso ha sido aceptado solo porque tiene operaciones de lenguaje imperativo , lo que hace posibles efectos secundarios no deseados. ^[78]

ML (1973) ^[85] significa "Meta Lenguaje". ML verifica que solo se comparen entre sí datos del mismo tipo. ^[86] Por ejemplo, esta función tiene un parámetro de entrada (un entero) y devuelve un entero:

diversión  veces_10 ( n  :  int )  :  int  =  10  *  n ;

ML no es excéntrico en cuanto a paréntesis como Lisp . La siguiente es una aplicación de times_10():

veces_10 2

Devuelve "20 : int". (Se devuelven tanto los resultados como el tipo de datos).

Al igual que Lisp , ML está diseñado para procesar listas. A diferencia de Lisp , cada elemento es del mismo tipo de datos. ^[87] Además, ML asigna el tipo de datos de un elemento en tiempo de compilación . La asignación del tipo de datos en tiempo de compilación se denomina enlace estático . El enlace estático aumenta la confiabilidad porque el compilador verifica el contexto de las variables antes de que se utilicen. ^[88]

Prolog (1972) significa "PROgramming in LOGic" (PROgramación en lógica). Es un lenguaje de programación lógica , basado en la lógica formal . El lenguaje fue desarrollado por Alain Colmerauer y Philippe Roussel en Marsella, Francia. Es una implementación de la resolución de cláusulas definidas lineales selectivas , iniciada por Robert Kowalski y otros en la Universidad de Edimburgo . ^[89]

Los elementos básicos de un programa Prolog son hechos y reglas . A continuación se muestra un ejemplo sencillo:

gato ( tom ).  % tom es un gato ratón ( jerry ).  % jerry es un ratónanimal ( X )  :-  gato ( X ).  % cada gato es un animal animal ( X ) :  -  ratón ( X ).  % cada ratón es un animalgrande ( X )  :-  gato ( X ).  % cada gato es grande pequeño ( X )  :-  ratón ( X ).  % cada ratón es pequeñocomer ( X , Y )  :-  ratón ( X ),  queso ( Y ).  % cada ratón come cada queso comer ( X , Y )  :-  grande ( X ),  pequeño ( Y ).  % cada animal grande come cada animal pequeño

Una vez introducidos todos los hechos y reglas, se puede plantear una pregunta:

¿Tom se comerá a Jerry?

?-  comer ( tom , jerry ). verdadero

El siguiente ejemplo muestra cómo Prolog convertirá una calificación de letra en su valor numérico:

calificación_numérica ( 'A' ,  4 ). calificación_numérica ( 'B' ,  3 ). calificación_numérica ( 'C' ,  2 ). calificación_numérica ( 'D' ,  1 ). calificación_numérica ( 'F' ,  0 ). calificación_numérica ( X ,  - 1 )  :-  no  X  =  'A' ,  no  X  =  'B' ,  no  X  =  'C' ,  no  X  =  'D' ,  no  X  =  'F' . calificación ( 'El estudiante' ,  'A' ).

?-  grado ( 'El estudiante' ,  X ),  grado_numérico ( X ,  Y ). X  =  'A' , Y  =  4

He aquí un ejemplo completo: ^[90]

1) Todos los dragones arrojan fuego, o equivalentemente, una cosa arroja fuego si la cosa es un dragón:

olas_de_fuego ( X )  :-  es_un_dragon ( X ).

2) Una criatura lanza fuego si uno de sus padres lanza fuego:

billows_fire ( X )  :-  es_una_criatura ( X ),  es_un_padre_de ( Y , X ),  billows_fire ( Y ).

3) Una cosa X es padre de una cosa Y si X es la madre de Y o X es el padre de Y:

es_padre_de ( X ,  Y ):-  es_la_madre_de ( X ,  Y ). es_padre_de ( X ,  Y ):-  es_el_padre_de ( X ,  Y ).

4) Una cosa es una criatura si la cosa es un dragón:

es_una_criatura ( X )  :-  es_un_dragón ( X ).

5) Norberta es un dragón y Puff es una criatura. Norberta es la madre de Puff.

es_un_dragón ( norberta ). es_una_criatura ( puff ). es_la_madre_de ( norberta ,  puff ).

La regla (2) es una definición recursiva (inductiva). Puede entenderse de manera declarativa, sin necesidad de entender cómo se ejecuta.

La regla (3) muestra cómo se representan las funciones mediante relaciones. Aquí, las funciones madre y padre garantizan que cada individuo tenga solo una madre y solo un padre.

Prolog es un lenguaje sin tipos. No obstante, la herencia se puede representar mediante predicados. La regla (4) afirma que una criatura es una superclase de un dragón.

Las preguntas se responden mediante razonamiento inverso . Dada la pregunta:

 ?  -olas_de_fuego ( X ).

Prolog genera dos respuestas:

X  =  norberta X  =  puff

Las aplicaciones prácticas de Prolog son la representación del conocimiento y la resolución de problemas en inteligencia artificial .

La programación orientada a objetos es un método de programación para ejecutar operaciones ( funciones ) sobre objetos . ^[91] La idea básica es agrupar las características de un fenómeno en un contenedor de objetos y darle un nombre al contenedor. Las operaciones sobre el fenómeno también se agrupan en el contenedor. ^[91] La programación orientada a objetos se desarrolló combinando la necesidad de contenedores y la necesidad de una programación funcional segura . ^[92] Este método de programación no necesita limitarse a un lenguaje orientado a objetos . ^[93] En un lenguaje orientado a objetos, un contenedor de objetos se llama clase . En un lenguaje no orientado a objetos, una estructura de datos (que también se conoce como registro ) puede convertirse en un contenedor de objetos. Para convertir una estructura de datos en un contenedor de objetos, es necesario escribir operaciones específicamente para la estructura. La estructura resultante se llama tipo de datos abstracto . ^[94] Sin embargo, faltará la herencia . No obstante, esta deficiencia se puede superar.

A continuación se muestra un archivo de encabezado en lenguaje de programación C para el tipo de datos abstracto GRADE en una aplicación escolar simple:

/* grado.h */ /* ------- *//* Se utiliza para permitir que varios archivos de origen incluyan */ /* este archivo de encabezado sin errores de duplicación. */ /* ---------------------------------------------- */ #ifndef GRADE_H #define GRADE_Htypedef struct { char letra ; } CALIFICACIÓN ;    /* Constructor */ /* ----------- */ GRADE * grade_new ( char letra );    int grado_numérico ( char letra ); #endif    

La grade_new()función realiza el mismo algoritmo que la operación constructora de C++ .

A continuación se muestra un archivo fuente del lenguaje de programación C para el tipo de datos abstracto GRADE en una aplicación escolar simple:

/* calificación.c */ /* ------- */ #include "calificación.h" CALIFICACIÓN * calificación_nueva ( char letra ) { CALIFICACIÓN * calificación ;       /* Asignar memoria de montón */ /* -------------------- */ if ( ! ( grade = calloc ( 1 , sizeof ( GRADE ) ) ) ) { fprintf ( stderr , "ERROR en %s/%s/%d: calloc() devolvió vacío. \n " , __FILE__ , __FUNCTION__ , __LINE__ ); exit ( 1 ); }                            calificación -> letra = letra ; devolver calificación ; }    int grado_numérico ( char letra ) { if ( ( letra == 'A' || letra == 'a' ) ) devuelve 4 ; de lo contrario if ( ( letra == 'B' || letra == 'b' ) ) devuelve 3 ; de lo contrario if ( ( letra == 'C' || letra == 'c' ) ) devuelve 2 ; de lo contrario if ( ( letra == 'D' || letra == 'd' ) ) devuelve 1 ; de lo contrario if ( ( letra == 'F' || letra == 'f' ) ) devuelve 0 ; de lo contrario devuelve -1 ; }                                                                                 

En el constructor, calloc()se utiliza la función en lugar de malloc()porque cada celda de memoria se establecerá en cero.

A continuación se muestra un archivo de encabezado en lenguaje de programación C para el tipo de datos abstracto PERSONA en una aplicación escolar simple:

/* persona.h */ /* -------- */ #ifndef PERSONA_H #define PERSONA_Htypedef struct { char * nombre ; } PERSONA ;    /* Constructor */ /* ----------- */ PERSONA * persona_nueva ( char * nombre ); #endif    

A continuación se muestra un archivo fuente del lenguaje de programación C para el tipo de datos abstracto PERSONA en una aplicación escolar simple:

/* persona.c */ /* -------- */ #include "persona.h" PERSONA * persona_nueva ( char * nombre ) { PERSONA * persona ;       if ( ! ( person = calloc ( 1 , sizeof ( PERSON ) ) ) ) { fprintf ( stderr , "ERROR en %s/%s/%d: calloc() devolvió vacío. \n " , __FILE__ , __FUNCTION__ , __LINE__ ); exit ( 1 ); }                          persona -> nombre = nombre ; devolver persona ; }    

A continuación se muestra un archivo de encabezado en lenguaje de programación C para el tipo de datos abstracto ESTUDIANTE en una aplicación escolar simple:

/* estudiante.h */ /* --------- */ #ifndef ESTUDIANTE_H #define ESTUDIANTE_H#include "persona.h" #include "calificación.h"  typedef struct { /* Un ESTUDIANTE es un subconjunto de PERSONA. */ /* -------------------------------- */ PERSONA * persona ;      CALIFICACIÓN * calificación ; } ESTUDIANTE ;  /* Constructor */ /* ----------- */ ESTUDIANTE * estudiante_nuevo ( char * nombre ); #endif    

A continuación se muestra un archivo fuente del lenguaje de programación C para el tipo de datos abstracto ESTUDIANTE en una aplicación escolar simple:

/* estudiante.c */ /* --------- */ #include "estudiante.h" #include "persona.h"  ESTUDIANTE * estudiante_nuevo ( char * nombre ) { ESTUDIANTE * estudiante ;       if ( ! ( student = calloc ( 1 , sizeof ( STUDENT ) ) ) ) { fprintf ( stderr , "ERROR en %s/%s/%d: calloc() devolvió vacío. \n " , __FILE__ , __FUNCTION__ , __LINE__ ); exit ( 1 ); }                          /* Ejecuta el constructor de la superclase PERSONA. */ /* ------------------------------------------------- */ estudiante -> persona = persona_nueva ( nombre ); return estudiante ; }        

A continuación se muestra un programa de controlador para demostración:

/* estudiante_dvr.c */ /* ------------- */ #include <stdio.h> #include "estudiante.h"  int main ( void ) { ESTUDIANTE * estudiante = estudiante_nuevo ( "El Estudiante" ); estudiante -> calificación = calificación_nuevo ( 'a' );               printf ( "%s: Calificación numérica = %d \n " , /* Mientras que existe un subconjunto, la herencia no existe. */ estudiante -> persona -> nombre , /* La programación funcional es ejecutar funciones justo a tiempo (JIT) */ calificación_numérica ( estudiante -> calificación -> letra ) );        devuelve 0 ; } 

Aquí hay un makefile para compilar todo:

# makefile # -------- todos : student_dvr limpio :  rm  student_dvr  *.ostudent_dvr : student_dvr . c grado . o estudiante . o persona . o gcc student_dvr.c grado.o estudiante.o persona.o -o student_dvr           grado.o : grado.c grado.h gcc -c grado.c​​​​     estudiante.o : estudiante .c estudiante .h gcc -c estudiante.c​​     persona.o : persona . c persona . h gcc -c persona.c     

La estrategia formal para construir objetos orientados a objetos es: ^[95]

• Identifica los objetos. Lo más probable es que sean sustantivos.
• Identifica los atributos de cada objeto. ¿Qué ayuda a describir el objeto?
• Identifica las acciones de cada objeto. Lo más probable es que sean verbos.
• Identifica las relaciones entre objetos. Lo más probable es que sean verbos.

Por ejemplo:

• Una persona es un ser humano identificado por un nombre.
• Una calificación es un logro identificado por una letra.
• Un estudiante es una persona que obtiene una calificación.

La sintaxis de un programa de computadora es una lista de reglas de producción que forman su gramática . ^[96] La gramática de un lenguaje de programación coloca correctamente sus declaraciones , expresiones y enunciados . ^[97] Complementando la sintaxis de un lenguaje está su semántica . La semántica describe los significados asociados a varias construcciones sintácticas. ^[98] Una construcción sintáctica puede necesitar una descripción semántica porque una regla de producción puede tener una interpretación inválida. ^[99] Además, diferentes lenguajes pueden tener la misma sintaxis; sin embargo, sus comportamientos pueden ser diferentes.

La sintaxis de un idioma se describe formalmente mediante la enumeración de las reglas de producción. Mientras que la sintaxis de un idioma natural es extremadamente complicada, un subconjunto del idioma inglés puede tener esta lista de reglas de producción: ^[100]

1. una oración se compone de un sintagma nominal seguido de un sintagma verbal ;
2. un sintagma nominal se compone de un artículo seguido de un adjetivo seguido de un sustantivo ;
3. un sintagma verbal se compone de un verbo seguido de un sintagma nominal ;
4. un artículo es 'el';
5. un adjetivo es 'grande' o
6. un adjetivo es 'pequeño';
7. un sustantivo es 'gato' o
8. un sustantivo es 'ratón';
9. un verbo es 'come';

Las palabras en negrita se conocen como no terminales . Las palabras entre comillas simples se conocen como terminales . ^[101]

A partir de esta lista de reglas de producción, se pueden formar oraciones completas utilizando una serie de reemplazos. ^[102] El proceso consiste en reemplazar los no terminales con un no terminal válido o un terminal válido . El proceso de reemplazo se repite hasta que solo queden terminales . Una oración válida es:

• oración
• frase nominal frase verbal
• artículo adjetivo sustantivo verbo-frase
• el adjetivo sustantivo verbo-frase
• La gran frase sustantiva- verbal
• el gran gato frase verbal
• el gran gato verbo sustantivo-frase
• El gran gato come frase nominal
• el gran gato come artículo adjetivo sustantivo
• El gran gato se come el sustantivo adjetivo
• El gato grande se come al pequeño sustantivo
• El gato grande se come al ratón pequeño

Sin embargo, otra combinación da como resultado una oración inválida:

• El pequeño ratón se come al gato grande

Por lo tanto, es necesaria una semántica para describir correctamente el significado de una actividad alimentaria .

Un método de listado de reglas de producción se denomina forma Backus–Naur (BNF). ^[103] La BNF describe la sintaxis de un lenguaje y tiene una sintaxis . Esta definición recursiva es un ejemplo de un metalenguaje . ^[98] La sintaxis de la BNF incluye:

• ::=que se traduce como se compone de a[n] cuando un no terminal está a su derecha. Se traduce como es cuando un terminal está a su derecha.
• |que se traduce como o .
• <y >que rodean los no terminales .

Usando BNF, un subconjunto del idioma inglés puede tener este listado de reglas de producción :

< oración >  ::=  < sintagma nominal >< sintagma verbal > < sintagma nominal >  ::=  < artículo >< adjetivo >< sustantivo > < sintagma verbal >  ::=  < verbo >< sintagma nominal > < artículo >  ::= el < adjetivo >  ::= grande | pequeño < sustantivo >  ::= gato | ratón < verbo >  ::= come

Usando BNF, un entero con signo tiene la regla de producción que se detalla: ^[104]

< entero con signo >  ::=  < signo >< entero > < signo >  ::= + | - < entero >  ::=  < dígito > | < dígito >< entero > < dígito >  ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Tenga en cuenta la regla de producción recursiva:

< entero >  ::=  < dígito > | < dígito >< entero >

Esto permite un número infinito de posibilidades, por lo que es necesaria una semántica que describa una limitación del número de dígitos.

Observe la posibilidad del cero inicial en las reglas de producción:

< entero >  ::=  < dígito > | < dígito >< entero > < dígito >  ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Por lo tanto, es necesaria una semántica para describir que los ceros iniciales deben ignorarse.

Existen dos métodos formales para describir la semántica : la semántica denotacional y la semántica axiomática . ^[105]

La ingeniería de software es una variedad de técnicas para producir programas informáticos de calidad . ^[106] La programación informática es el proceso de escribir o editar código fuente . En un entorno formal, un analista de sistemas recopilará información de los gerentes sobre todos los procesos de la organización que se van a automatizar. Luego, este profesional prepara un plan detallado para el sistema nuevo o modificado. ^[107] El plan es análogo al plano de un arquitecto. ^[107]

El analista de sistemas tiene como objetivo entregar la información correcta a la persona correcta en el momento correcto. ^[108] Los factores críticos para lograr este objetivo son: ^[108]

1. La calidad de los resultados. ¿Son útiles para la toma de decisiones?
2. La precisión de los resultados. ¿Refleja la situación real?
3. El formato del resultado. ¿Se entiende fácilmente el resultado?
4. La velocidad de la salida. La información sensible al tiempo es importante cuando se comunica con el cliente en tiempo real.

El logro de los objetivos de desempeño debe equilibrarse con todos los costos, incluidos: ^[109]

1. Costos de desarrollo.
2. Costos de unicidad. Un sistema reutilizable puede ser costoso, pero puede ser preferible a un sistema de uso limitado.
3. Costos de hardware.
4. Costos de operación.

La aplicación de un proceso de desarrollo de sistemas mitigará el axioma: cuanto más tarde en el proceso se detecta un error, más costoso es corregirlo. ^[110]

El modelo en cascada es una implementación de un proceso de desarrollo de sistemas . ^[111] Como lo implica la etiqueta de cascada , las fases básicas se superponen entre sí: ^[112]

1. La fase de investigación consiste en comprender el problema subyacente.
2. La fase de análisis es comprender las posibles soluciones.
3. La fase de diseño consiste en planificar la mejor solución.
4. La fase de implementación consiste en programar la mejor solución.
5. La fase de mantenimiento dura toda la vida útil del sistema. Es posible que sea necesario realizar cambios en el sistema después de su implementación. ^[113] Pueden existir fallas, incluidas fallas de especificación, fallas de diseño o fallas de codificación. Es posible que sea necesario realizar mejoras. Es posible que sea necesario realizar adaptaciones para reaccionar ante un entorno cambiante.

Un programador informático es un especialista responsable de escribir o modificar el código fuente para implementar el plan detallado. ^[107] Es probable que se necesite un equipo de programación porque la mayoría de los sistemas son demasiado grandes para que un solo programador los complete. ^[114] Sin embargo, agregar programadores a un proyecto puede no acortar el tiempo de finalización. En cambio, puede reducir la calidad del sistema. ^[114] Para que sea eficaz, los módulos del programa deben definirse y distribuirse a los miembros del equipo. ^[114] Además, los miembros del equipo deben interactuar entre sí de una manera significativa y eficaz. ^[114]

Los programadores informáticos pueden programar en lo pequeño : programar dentro de un solo módulo. ^[115] Es probable que un módulo ejecute módulos ubicados en otros archivos de código fuente. Por lo tanto, los programadores informáticos pueden programar en lo grande : programar módulos para que se acoplen entre sí de manera efectiva. ^[115] La programación en lo grande incluye contribuir a la interfaz de programación de aplicaciones (API).

La programación modular es una técnica para refinar programas en lenguaje imperativo . Los programas refinados pueden reducir el tamaño del software, separar responsabilidades y, por lo tanto, mitigar el envejecimiento del software . Un módulo de programa es una secuencia de instrucciones que están delimitadas dentro de un bloque y que se identifican entre sí mediante un nombre. ^[116] Los módulos tienen una función , un contexto y una lógica : ^[117]

• La función de un módulo es lo que hace.
• El contexto de un módulo son los elementos sobre los que se realiza la acción.
• La lógica de un módulo es cómo realiza la función.

El nombre del módulo debe derivarse primero de su función y luego de su contexto . Su lógica no debe ser parte del nombre. ^[117] Por ejemplo, function compute_square_root( x )o function compute_square_root_integer( i : integer )son nombres de módulo apropiados. Sin embargo, function compute_square_root_by_division( x )no lo es.

El grado de interacción dentro de un módulo es su nivel de cohesión . ^[117] La ​​cohesión es un juicio de la relación entre el nombre de un módulo y su función . El grado de interacción entre módulos es el nivel de acoplamiento . ^[118] El acoplamiento es un juicio de la relación entre el contexto de un módulo y los elementos sobre los que se realiza la ejecución.

Los niveles de cohesión de peor a mejor son: ^[119]

• Cohesión coincidente : un módulo tiene cohesión coincidente si realiza múltiples funciones y estas funciones no están relacionadas en absoluto. Por ejemplo, function read_sales_record_print_next_line_convert_to_float(). La cohesión coincidente ocurre en la práctica si la administración aplica reglas absurdas. Por ejemplo, "Cada módulo tendrá entre 35 y 50 sentencias ejecutables". ^[119]
• Cohesión lógica: Un módulo tiene cohesión lógica si tiene disponibles una serie de funciones, pero solo se ejecuta una de ellas. Por ejemplo, function perform_arithmetic( perform_addition, a, b ).
• Cohesión temporal : un módulo tiene cohesión temporal si realiza funciones relacionadas con el tiempo. Un ejemplo, function initialize_variables_and_open_files(). Otro ejemplo, stage_one(), stage_two(), ...
• Cohesión procedimental : un módulo tiene cohesión procedimental si realiza múltiples funciones vagamente relacionadas. Por ejemplo, function read_part_number_update_employee_record().
• Cohesión comunicacional : Un módulo tiene cohesión comunicacional si realiza múltiples funciones estrechamente relacionadas. Por ejemplo, function read_part_number_update_sales_record().
• Cohesión informativa : un módulo tiene cohesión informativa si realiza múltiples funciones, pero cada una de ellas tiene sus propios puntos de entrada y salida. Además, las funciones comparten la misma estructura de datos. Las clases orientadas a objetos funcionan en este nivel.
• Cohesión funcional : un módulo tiene cohesión funcional si logra un único objetivo trabajando únicamente sobre variables locales. Además, puede reutilizarse en otros contextos.

Los niveles de acoplamiento de peor a mejor son: ^[118]

• Acoplamiento de contenido : un módulo tiene acoplamiento de contenido si modifica una variable local de otra función. COBOL solía hacer esto con el verbo alter .
• Acoplamiento común : un módulo tiene acoplamiento común si modifica una variable global.
• Acoplamiento de control : un módulo tiene acoplamiento de control si otro módulo puede modificar su flujo de control . Por ejemplo, perform_arithmetic( perform_addition, a, b ). En cambio, el control debería estar en la composición del objeto devuelto.
• Acoplamiento de sellos : un módulo tiene acoplamiento de sellos si se modifica un elemento de una estructura de datos que se pasa como parámetro. Las clases orientadas a objetos funcionan en este nivel.
• Acoplamiento de datos : un módulo tiene acoplamiento de datos si se necesitan todos sus parámetros de entrada y no se modifica ninguno de ellos. Además, el resultado de la función se devuelve como un único objeto.

El análisis de flujo de datos es un método de diseño utilizado para lograr módulos de cohesión funcional y acoplamiento de datos . ^[120] La entrada al método es un diagrama de flujo de datos . Un diagrama de flujo de datos es un conjunto de óvalos que representan módulos. El nombre de cada módulo se muestra dentro de su óvalo. Los módulos pueden estar en el nivel ejecutable o en el nivel de función.

El diagrama también tiene flechas que conectan los módulos entre sí. Las flechas que apuntan hacia los módulos representan un conjunto de entradas. Cada módulo debe tener solo una flecha que apunta hacia afuera para representar su único objeto de salida. (Opcionalmente, una flecha de excepción adicional señala hacia afuera). Una cadena de óvalos transmitirá un algoritmo completo . Los módulos de entrada deben iniciar el diagrama. Los módulos de entrada deben conectarse a los módulos de transformación. Los módulos de transformación deben conectarse a los módulos de salida. ^[121]

Los programas de ordenador pueden clasificarse según líneas funcionales. Las principales categorías funcionales son el software de aplicación y el software de sistema . El software de sistema incluye el sistema operativo , que acopla el hardware del ordenador con el software de aplicación. ^[122] El propósito del sistema operativo es proporcionar un entorno donde el software de aplicación se ejecute de una manera conveniente y eficiente. ^[122] Tanto el software de aplicación como el software de sistema ejecutan programas de utilidad . A nivel de hardware, un programa de microcódigo controla los circuitos en toda la unidad central de procesamiento .

El software de aplicación es la clave para liberar el potencial del sistema informático. ^[123] El software de aplicación empresarial agrupa aplicaciones de contabilidad, personal, clientes y proveedores. Algunos ejemplos incluyen planificación de recursos empresariales , gestión de relaciones con clientes y software de gestión de la cadena de suministro .

Las aplicaciones empresariales pueden desarrollarse internamente como un software propietario único . ^[124] Alternativamente, pueden comprarse como software estándar . El software comprado puede modificarse para proporcionar software personalizado . Si la aplicación se personaliza, se utilizan los recursos de la empresa o se subcontratan. El desarrollo de software subcontratado puede ser del proveedor de software original o de un desarrollador externo. ^[125]

Las posibles ventajas del software interno son que las características y los informes se pueden desarrollar exactamente según las especificaciones. ^[126] La gerencia también puede participar en el proceso de desarrollo y ofrecer un nivel de control. ^[127] La ​​gerencia puede decidir contrarrestar la nueva iniciativa de un competidor o implementar un requisito de un cliente o proveedor. ^[128] Una fusión o adquisición puede requerir cambios en el software empresarial. Las posibles desventajas del software interno son que los costos de tiempo y recursos pueden ser elevados. ^[124] Además, pueden estar apareciendo riesgos relacionados con las características y el rendimiento.

Las ventajas potenciales del software comercial son que los costos iniciales son identificables, las necesidades básicas deben ser satisfechas y su desempeño y confiabilidad tienen un historial de éxito. ^[124] Las desventajas potenciales del software comercial son que puede tener características innecesarias que confunden a los usuarios finales, puede carecer de características que la empresa necesita y el flujo de datos puede no coincidir con los procesos de trabajo de la empresa. ^[124]

Una forma de obtener de forma económica una aplicación empresarial personalizada es a través de un proveedor de servicios de aplicaciones . ^[129] Las empresas especializadas proporcionan hardware, software personalizado y soporte al usuario final. Pueden acelerar el desarrollo de nuevas aplicaciones porque poseen personal capacitado en sistemas de información. La mayor ventaja es que libera a los recursos internos de la tarea de contratar personal y gestionar proyectos informáticos complejos. ^[129] Muchos proveedores de servicios de aplicaciones se dirigen a empresas pequeñas y de rápido crecimiento con recursos limitados en sistemas de información. ^[129] Por otro lado, las empresas más grandes con sistemas importantes probablemente tendrán su infraestructura técnica en su lugar. Un riesgo es tener que confiar en una organización externa con información confidencial. Otro riesgo es tener que confiar en la fiabilidad de la infraestructura del proveedor. ^[129]

Un sistema operativo es el software de bajo nivel que soporta las funciones básicas de una computadora, como programar procesos y controlar periféricos . ^[122]

En la década de 1950, el programador, que también era el operador, escribía un programa y lo ejecutaba. Una vez que el programa terminaba de ejecutarse, el resultado podía imprimirse o perforarse en una cinta de papel o en tarjetas para su posterior procesamiento. ^[28] La mayoría de las veces, el programa no funcionaba. El programador miraba entonces las luces de la consola y jugaba con los interruptores de la misma. Si no tenía tanta suerte, hacía una impresión de memoria para estudiarla más a fondo. En la década de 1960, los programadores redujeron la cantidad de tiempo perdido automatizando el trabajo del operador. En todo momento se guardaba en la computadora un programa llamado sistema operativo . ^[130]

El término sistema operativo puede referirse a dos niveles de software. ^[131] El sistema operativo puede referirse al programa del núcleo que administra los procesos , la memoria y los dispositivos . En términos más generales, el sistema operativo puede referirse a todo el paquete de software central. El paquete incluye un programa del núcleo, un intérprete de línea de comandos , una interfaz gráfica de usuario , programas de utilidad y un editor . ^[131]

El propósito principal del kernel es administrar los recursos limitados de una computadora:

• El programa del núcleo debe realizar la programación de procesos , ^[132] lo que también se conoce como cambio de contexto . El núcleo crea un bloque de control de procesos cuando se selecciona un programa de computadora para su ejecución . Sin embargo, un programa en ejecución obtiene acceso exclusivo a la unidad central de procesamiento solo durante un intervalo de tiempo . Para proporcionar a cada usuario la apariencia de acceso continuo , el núcleo reemplaza rápidamente cada bloque de control de procesos para ejecutar otro. El objetivo de los desarrolladores de sistemas es minimizar la latencia de despacho .

• El programa del kernel debe realizar la gestión de la memoria .

• Cuando el núcleo carga inicialmente un ejecutable en la memoria, divide el espacio de direcciones de manera lógica en regiones . ^[133] El núcleo mantiene una tabla de región maestra y muchas tablas de región por proceso (pregion), una para cada proceso en ejecución . ^[133] Estas tablas constituyen el espacio de direcciones virtuales . La tabla de región maestra se utiliza para determinar dónde se encuentran sus contenidos en la memoria física . Las tablas pregion permiten que cada proceso tenga su propia pregion de programa (texto), pregion de datos y pregion de pila.
• La región del programa almacena instrucciones de la máquina. Dado que las instrucciones de la máquina no cambian, la región del programa puede ser compartida por muchos procesos del mismo ejecutable. ^[133]
• Para ahorrar tiempo y memoria, el núcleo puede cargar sólo bloques de instrucciones de ejecución desde la unidad de disco, no todo el archivo de ejecución por completo. ^[132]
• El núcleo es responsable de traducir las direcciones virtuales a direcciones físicas . El núcleo puede solicitar datos al controlador de memoria y, en su lugar, recibir un error de página . ^[134] Si es así, el núcleo accede a la unidad de gestión de memoria para rellenar la región de datos físicos y traducir la dirección. ^[135]
• El núcleo asigna memoria del montón a petición de un proceso. ^[64] Cuando el proceso termina de utilizar la memoria, puede solicitar que se libere . Si el proceso finaliza sin solicitar que se libere toda la memoria asignada, el núcleo realiza una recolección de basura para liberar la memoria.
• El núcleo también garantiza que un proceso sólo acceda a su propia memoria, y no a la del núcleo o de otros procesos. ^[132]

• El programa del núcleo debe realizar la gestión del sistema de archivos . ^[132] El núcleo tiene instrucciones para crear, recuperar, actualizar y eliminar archivos.
• El programa del núcleo debe realizar la gestión de dispositivos . ^[132] El núcleo proporciona programas para estandarizar y simplificar la interfaz con el ratón, el teclado, las unidades de disco, las impresoras y otros dispositivos. Además, el núcleo debe arbitrar el acceso a un dispositivo si dos procesos lo solicitan al mismo tiempo.
• El programa del núcleo debe realizar la gestión de la red . ^[136] El núcleo transmite y recibe paquetes en nombre de los procesos. Un servicio clave es encontrar una ruta eficiente al sistema de destino.
• El programa del núcleo debe proporcionar funciones a nivel de sistema para que los programadores las utilicen. ^[137]
  • Los programadores acceden a los archivos a través de una interfaz relativamente simple que, a su vez, ejecuta una interfaz de E/S de bajo nivel relativamente complicada. La interfaz de bajo nivel incluye la creación de archivos, los descriptores de archivos , la búsqueda de archivos, la lectura física y la escritura física.
  • Los programadores crean procesos a través de una interfaz relativamente simple que a su vez ejecuta una interfaz de bajo nivel relativamente complicada.
  • Los programadores realizan cálculos aritméticos de fecha y hora a través de una interfaz relativamente simple que a su vez ejecuta una interfaz de tiempo de bajo nivel relativamente complicada. ^[138]
• El programa del núcleo debe proporcionar un canal de comunicación entre los procesos en ejecución. ^[139] En el caso de un sistema de software de gran tamaño, puede ser conveniente diseñar el sistema en procesos más pequeños. Los procesos pueden comunicarse entre sí enviando y recibiendo señales .

Originalmente, los sistemas operativos se programaban en ensamblador ; sin embargo, los sistemas operativos modernos suelen estar escritos en lenguajes de nivel superior como C , Objective-C y Swift . ^[k]

Un programa de utilidad está diseñado para ayudar a la administración del sistema y la ejecución del software. Los sistemas operativos ejecutan programas de utilidad de hardware para verificar el estado de las unidades de disco, la memoria, los altavoces y las impresoras. ^[140] Un programa de utilidad puede optimizar la ubicación de un archivo en un disco abarrotado. Los programas de utilidad del sistema monitorean el rendimiento del hardware y la red. Cuando una métrica está fuera de un rango aceptable, se genera una alerta de activación. ^[141]

Los programas de utilidad incluyen programas de compresión para que los archivos de datos se almacenen en menos espacio en disco. ^[140] Los programas comprimidos también ahorran tiempo cuando los archivos de datos se transmiten a través de la red. ^[140] Los programas de utilidad pueden ordenar y fusionar conjuntos de datos. ^[141] Los programas de utilidad detectan virus informáticos . ^[141]

Un programa de microcódigo es el intérprete de nivel inferior que controla la ruta de datos de las computadoras controladas por software. ^[142] (Los avances en hardware han migrado estas operaciones a circuitos de ejecución de hardware ). ^[142] Las instrucciones de microcódigo permiten al programador implementar más fácilmente el nivel de lógica digital ^[143] —el hardware real de la computadora. El nivel de lógica digital es el límite entre la ciencia informática y la ingeniería informática . ^[144]

Una puerta lógica es un pequeño transistor que puede devolver una de dos señales: encendido o apagado. ^[145]

• Tener un transistor forma la puerta NOT .
• La conexión de dos transistores en serie forma la puerta NAND .
• Conectando dos transistores en paralelo se forma la puerta NOR .
• Conectar una puerta NOT a una puerta NAND forma la puerta AND .
• Conectando una puerta NOT a una puerta NOR se forma la puerta OR .

Estas cinco puertas forman los componentes básicos del álgebra binaria : las funciones lógicas digitales de la computadora.

Las instrucciones de microcódigo son mnemotecnias que los programadores pueden usar para ejecutar funciones lógicas digitales en lugar de formarlas en álgebra binaria. Se almacenan en el almacén de control de una unidad central de procesamiento (CPU) . ^[146] Estas instrucciones a nivel de hardware mueven datos a lo largo de la ruta de datos .

El ciclo de microinstrucción comienza cuando el microsecuenciador utiliza su contador de microprograma para buscar la siguiente instrucción de máquina desde la memoria de acceso aleatorio . ^[147] El siguiente paso es decodificar la instrucción de máquina seleccionando la línea de salida adecuada para el módulo de hardware. ^[148] El paso final es ejecutar la instrucción utilizando el conjunto de puertas del módulo de hardware.

Las instrucciones para realizar operaciones aritméticas pasan a través de una unidad aritmética lógica (ALU). ^[149] La ALU tiene circuitos para realizar operaciones elementales para sumar, desplazar y comparar números enteros. Al combinar y repetir las operaciones elementales a través de la ALU, la CPU realiza su aritmética compleja.

Las instrucciones de microcódigo mueven datos entre la CPU y el controlador de memoria . Las instrucciones de microcódigo del controlador de memoria manipulan dos registros . El registro de dirección de memoria se utiliza para acceder a la dirección de cada celda de memoria. El registro de datos de memoria se utiliza para configurar y leer el contenido de cada celda. ^[150]

Las instrucciones de microcódigo mueven datos entre la CPU y los distintos buses de la computadora . El bus del controlador de disco escribe y lee en las unidades de disco duro . Los datos también se mueven entre la CPU y otras unidades funcionales a través del bus exprés de interconexión de componentes periféricos. ^[151]