Programa informático

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

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

En 1936, Alan Turing presentó la máquina de Turing universal , un dispositivo teórico capaz de modelar cualquier computación. ^{[ 16 ]} Es una máquina de estados finitos con una cinta de lectura/escritura de longitud infinita. La máquina puede mover la cinta hacia adelante y hacia atrás, modificando su contenido a medida que ejecuta un algoritmo . La máquina comienza en el estado inicial, realiza una secuencia de pasos y se detiene al alcanzar el estado de parada. ^{[ 17 ]} Todas las computadoras actuales son Turing completas . ^{[ 18 ]}

El Integrador y Computador Numérico Electrónico (ENIAC) se construyó entre julio de 1943 y otoño de 1945. Era una computadora de propósito general, completa de Turing, que utilizaba 17.468 tubos de vacío para crear los circuitos . En su núcleo, era una serie de Pascalinas interconectadas. ^{[ 19 ]} Sus 40 unidades pesaban 30 toneladas, ocupaban 167 m² (1.800 pies ^cuadrados ) y consumían 650 dólares por hora ( en moneda de la década de 1940 ) en electricidad cuando estaba inactiva. ^{[ 19 ]} Tenía 20 acumuladores de base 10. La programación del ENIAC podía tardar hasta dos meses. ^{[ 19 ]} Tres mesas de funciones estaban sobre ruedas y debían ser trasladadas a paneles de funciones fijos. Las mesas de funciones se conectaban a los paneles de funciones mediante gruesos cables negros en placas de conexiones . Cada mesa de funciones tenía 728 perillas giratorias. La programación del ENIAC también implicaba configurar algunos de los 3.000 interruptores. Depurar un programa llevaba una semana. ^{[ 20 ]} Estuvo en funcionamiento 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. ^{[ 21 ]} 

En lugar de conectar cables y accionar interruptores, una computadora de programa almacenado carga sus instrucciones en la memoria de la misma manera que carga sus datos. ^{[ 22 ]} Como resultado, la computadora podía programarse rápidamente y realizar cálculos a velocidades muy altas. ^{[ 23 ]} Presper Eckert y John Mauchly construyeron la ENIAC. Los dos ingenieros introdujeron el concepto de programa almacenado en un memorándum de tres páginas fechado en febrero de 1944. ^{[ 24 ]} 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 la EDVAC , que equiparaba las estructuras de la computadora con las estructuras del cerebro humano. ^{[ 23 ]} El diseño se conoció como la arquitectura von Neumann . La arquitectura se implementó simultáneamente en las construcciones de las computadoras EDVAC y EDSAC en 1949. ^{[ 25 ] [ 26 ]}

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 . ^{[ 27 ]} El Modelo 195 era el más premium. Cada modelo del System/360 presentaba multiprogramación ^{[ 27 ]} , es decir, tener múltiples procesos en memoria a la vez. Cuando un proceso estaba esperando entrada/salida , otro podía realizar cálculos.

IBM planeó que cada modelo se programara usando PL/I . ^{[ 28 ]} 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. ^{[ 28 ]} El resultado fue un lenguaje grande y complejo que requería mucho tiempo para compilarse . ^{[ 29 ]}

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

Un hito importante en el desarrollo de software fue la invención del circuito de integración a muy gran escala (VLSI, por sus siglas en inglés) (1964).

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). ^{[ 31 ]} El objetivo es alterar la resistividad y conductividad eléctrica de una unión semiconductora . Primero, los minerales de silicato presentes en la naturaleza se convierten en varillas de polisilicio utilizando el proceso Siemens . ^{[ 32 ]} El proceso Czochralski luego convierte las varillas en un cristal de silicio monocristalino , un boule . ^{[ 33 ]} El cristal luego se corta en láminas delgadas para formar un sustrato de oblea . El proceso planar de fotolitografía luego integra transistores unipolares, capacitores , diodos y resistencias ^{[ 34 ]} en la oblea para construir una matriz de transistores metal-óxido-semiconductor (MOS). El transistor MOS es el componente principal en los chips de circuitos integrados . ^{[ 31 ]}

Originalmente, la función de los chips de circuitos integrados se definía durante su fabricación. En la década de 1960, el control del flujo eléctrico evolucionó hacia la programación de una matriz de memoria de solo lectura (ROM). Esta matriz se asemejaba a una disposición bidimensional de fusibles. El proceso para grabar instrucciones en la matriz consistía en quemar las conexiones innecesarias.

En 1969, Busicom , una empresa japonesa de calculadoras, contrató a Intel para fabricar 12 chips de circuitos integrados, cada uno para una función específica de la calculadora. Ted Hoff , el ingeniero encargado del proyecto, se dio cuenta de que podía construir un chip capaz de ejecutar programas informáticos para realizar las 12 funciones de la calculadora. ^{[ 35 ]} El chip resultante se denominó microprocesador Intel 4004 .

Actualmente, 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 fabricada con placas de circuito impreso que contenían componentes discretos sobre sustratos cerámicos . ^{[ 36 ]}

En 1978, el entorno moderno de desarrollo de software comenzó cuando Intel actualizó el Intel 8080 al Intel 8086. Intel simplificó el Intel 8086 para fabricar el Intel 8088, más económico . ^{[ 37 ]} IBM adoptó el Intel 8088 cuando entró en el mercado de las computadoras personales (1981). A medida que aumentaba la demanda de computadoras personales por parte de los consumidores , también lo hacía 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 retrocompatibles . 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: ^{[ d ]}

• Instrucciones de memoria para establecer y acceder a números y cadenas en la memoria de acceso aleatorio .
• Instrucciones de la unidad lógica aritmético-lógica (ALU) de enteros para realizar las operaciones aritméticas primarias en enteros .
• Instrucciones ALU de punto flotante para realizar las operaciones aritméticas primarias con números reales .
• Las instrucciones de la pila de llamadas para insertar y extraer palabras son necesarias para asignar memoria e interactuar con las funciones .
• Instrucciones de instrucción única, datos múltiples (SIMD) ^{[ e ]} 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 único intérprete de comandos . Durante la década de 1970, la edición de código fuente a pantalla completa se hizo posible mediante una interfaz de usuario basada en texto . Independientemente de la tecnología disponible, el objetivo es programar en un lenguaje de programación .

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 . ^{[ 43 ]} La programación del EDSAC pertenecía a la primera generación de lenguajes de programación . ^{[ 44 ]}

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

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

• La estructura básica de una instrucció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 . Posteriormente, el ensamblador traducirá las etiquetas a direcciones de memoria física .
• Las operaciones permiten al programador trabajar con mnemónicos.
• Los operandos le indican al ensamblador qué datos procesará la operación. Posteriormente, el ensamblador traducirá los mnemónicos y los operandos en números de instrucción.
• Los comentarios permiten al programador articular una narrativa, ya que las instrucciones por sí solas pueden resultar incomprensibles para los humanos.

La característica clave de un programa en lenguaje ensamblador es que forma una correspondencia uno a uno con su correspondiente lenguaje máquina de destino. ^{[ 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 específico. ^{[ 49 ]} Los primeros lenguajes incluyen FORTAN (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 máquina eficientes. ^{[ 50 ]} Mientras que los lenguajes de tercera generación históricamente generaban muchas instrucciones de máquina para cada instrucción, ^{[ 51 ]} C tiene instrucciones que pueden generar una sola instrucción de máquina. ^{[ g ]} Además, un compilador optimizador podría anular al programador y producir menos instrucciones de máquina que instrucciones. Hoy en día, todo un paradigma de lenguajes llena el espectro imperativo de la tercera generación .

• La cuarta generación de lenguajes de programación enfatiza los resultados deseados, en lugar de cómo se deben construir las sentencias 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 es el Lenguaje de Consulta Estructurada (SQL). ^{[ 45 ]} Los desarrolladores de bases de datos ya no necesitan procesar cada registro de la base de datos uno por uno. Además, una simple sentencia SELECT puede generar registros de salida sin tener que entender cómo se recuperan.

Los lenguajes imperativos especifican un algoritmo secuencial mediante declaraciones , expresiones y sentencias : ^{[ 52 ]}

• Una declaración introduce un nombre de variable en el programa informático y lo asigna a un tipo de dato ^{[ 53 ]} – por ejemplo:var x: integer;
• Una expresión produce un valor; por ejemplo: 2 + 2produce 4
• Una instrucción puede 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();

do

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 posee las facilidades del lenguaje ensamblador , pero utiliza una sintaxis de alto nivel . Añadió características avanzadas como:

• ensamblador en línea
• aritmética con punteros
• punteros a funciones
• operaciones de bits
• Combinación libre de operadores complejos ^{[ 50 ]}

C permite al programador controlar en qué región de la memoria se almacenarán los datos. Las variables globales y estáticas requieren la menor cantidad de ciclos de reloj para su almacenamiento. 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 global y estático se encuentra justo encima de la región del programa . (Técnicamente, la región del programa se denomina región de texto . Es donde se almacenan las instrucciones de la máquina).

• La región de datos global y estática es técnicamente dos regiones. ^{[ 58 ]} Una región se llama segmento de datos inicializados , donde se almacenan las variables declaradas con valores predeterminados. La otra región se llama segmento de bloque iniciado por , donde se almacenan las variables declaradas sin valores predeterminados.
• Las variables almacenadas en la región de datos globales y estáticos tienen sus direcciones definidas en tiempo de compilación. Conservan sus valores durante toda la vida del proceso.

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

Por otro lado, las declaraciones de variables dentro de main()otras funciones o dentro {}de delimitadores de bloque son variables locales . Las variables locales también incluyen variables de parámetros formales . Las variables de parámetros están encerradas entre paréntesis en la definición de una función. ^{[ 60 ]} Los parámetros proporcionan una interfaz a la función.

• Las variables locales declaradas usando el staticprefijo también se almacenan en la región de datos global y estático . ^{[ 58 ]} A diferencia de las variables globales, las variables estáticas solo son visibles dentro de la función o 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;}^{[ i ]}

• 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 llenan de arriba a abajo. ^{[ j ] [ 61 ]} Un puntero de pila es un registro de propósito especial que mantiene un registro de la última dirección de memoria llenada. ^{[ 61 ]} Las variables se colocan en la pila mediante 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 ámbito es mediante la instrucción POP.

• Las variables locales declaradas sin el 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 ámbito al salir de la función o bloque.

• La región de 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 coinciden.

• C proporciona la malloc()función de biblioteca para asignar memoria del montón. ^{[ k ] [ 64 ]} Llenar el montón con datos es una función de copia adicional. ^{[ l ]} Las variables almacenadas en el montón se pasan de forma eficiente 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.

// grade.h // -------// Se utiliza para permitir que varios archivos fuente 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 numeric ; }; #endif

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

// person.h // -------- #ifndef PERSON_H #define PERSON_Hclase PERSONA { público : PERSONA ( const char * nombre ); const char * nombre ; }; #endif

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

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

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

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

# makefile # -------- all : student_dvrlimpiar : rm student_dvr *.o student_dvr : student_dvr.cpp grade.o student.o person.o c ++ student_dvr.cpp grade.o student.o person.o -o student_dvr​​​​​​​grade.o : grade . cpp grade . h c++ -c grade.cppestudiante.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 instrucción de asignación y el flujo de control. Describen qué cálculo debe realizarse y no cómo calcularlo. Dos grandes categorías de lenguajes declarativos son los lenguajes funcionales y los lenguajes lógicos .

El principio que subyace a 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 . Consideremos la función:

times_10(x) = 10 * x

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

times_10(2) = 20

Un compilador de lenguaje funcional no almacenará este valor en una variable. En su lugar, lo insertará en la pila del ordenador antes de restablecer el contador de programa a la función que lo llamó. La función que lo llamó extraerá entonces de la pila. ^{[ 75 ]}

Los lenguajes imperativos admiten funciones. Por lo tanto, la programación funcional puede lograrse en un lenguaje imperativo, si el programador aplica disciplina. Sin embargo, un lenguaje funcional impone 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 seguido de una única función controladora. ^{[ 73 ]} Considere el siguiente 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) );generará 6.

Los lenguajes funcionales se utilizan en la investigación en ciencias de la computación 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 ]}

fun times_10 ( n : int ) : int = 10 * n ;

veces_10 2

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

¿- comer ( tom , jerry ). verdadero

numeric_grade ( 'A' , 4 ). numeric_grade ( 'B' , 3 ). numeric_grade ( 'C' , 2 ). numeric_grade ( 'D' , 1 ). numeric_grade ( 'F' , 0 ). numeric_grade ( X , - 1 ) :- no X = 'A' , no X = 'B' , no X = 'C' , no X = 'D' , no X = 'F' . grade ( 'El estudiante' , 'A' ).

?- calificación ( 'El estudiante' , X ), calificación_numérica ( X , Y ). X = 'A' , Y = 4

billows_fire ( X ) :- is_a_dragon ( X ).

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

is_a_parent_of ( X , Y ):- is_the_mother_of ( X , Y ). is_a_parent_of ( X , Y ):- is_the_father_of ( X , Y ).

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

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

?- billows_fire ( X ).

X = norberta X = puff

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. 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 tiene por qué 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íficas para la estructura. La estructura resultante se llama tipo de dato abstracto . ^{[ 94 ]} Sin embargo, faltará la herencia . No obstante, esta limitación puede superarse.

Aquí se muestra un archivo de cabecera en lenguaje de programación C para el tipo de dato abstracto GRADE en una aplicación escolar sencilla:

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

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

Aquí tenéis un archivo fuente en lenguaje de programación C para el tipo de dato abstracto GRADE en una sencilla aplicación escolar:

/* grade.c */ /* ------- */ #include "grade.h"CALIFICACIÓN * calificación_nueva ( char letra ) { CALIFICACIÓN * calificación ;/* Asignar memoria del 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 calificación_numérica ( 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 ; }

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

Aquí tenéis un archivo de cabecera en lenguaje de programación C para el tipo de dato abstracto PERSON en una sencilla aplicación escolar:

/* person.h */ /* -------- */ #ifndef PERSON_H #define PERSON_Htypedef struct { char * nombre ; } PERSONA ;/* Constructor */ /* ----------- */ PERSONA * person_new ( char * nombre ); #endif

Aquí tenéis un archivo fuente en lenguaje de programación C para el tipo de dato abstracto PERSON en una sencilla aplicación escolar:

/* person.c */ /* -------- */ #include "person.h"PERSONA * person_new ( char * name ) { PERSONA * person ;/* Se omite la comprobación de errores */ persona = calloc ( 1 , sizeof ( PERSONA ) );persona -> nombre = nombre ; devolver persona ; }

Aquí se muestra un archivo de cabecera en lenguaje de programación C para el tipo de dato abstracto STUDENT en una aplicación escolar sencilla:

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

Aquí tenéis un archivo fuente en lenguaje de programación C para el tipo de dato abstracto ESTUDIANTE en una sencilla aplicación escolar:

/* student.c */ /* --------- */ #include "student.h" #include "person.h"ESTUDIANTE * estudiante_nuevo ( char * nombre ) { ESTUDIANTE * estudiante ;/* Se omite la comprobación de errores */ estudiante = calloc ( 1 , sizeof ( ESTUDIANTE ) ); /* Ejecutar el constructor de la superclase PERSONA. */ /* ------------------------------------------------- */ estudiante -> persona = person_new ( nombre ); return estudiante ; }

Aquí hay un programa de controlador a modo de demostración:

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

Aquí tenéis un archivo makefile para compilarlo todo:

# makefile # -------- all : student_dvrlimpiar : rm student_dvr *.o student_dvr : student_dvr.c calificación.o estudiante.o persona.o gcc student_dvr.c calificación.o estudiante.o persona.o -o student_dvr​​​​​​​​grado.o : grado . c grado . h gcc -c grado.cestudiante.o : estudiante . c estudiante . h gcc -c estudiante.cpersona.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 informático 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 sentencias . ^{[ 97 ]} Complementando la sintaxis de un lenguaje está su semántica . La semántica describe los significados asociados a diversas 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 compleja, un subconjunto del idioma inglés puede tener esta lista de reglas de producción: ^{[ 100 ]}

1. Una oración se compone de una frase nominal seguida de una frase verbal ;
2. Una frase nominal se compone de un artículo seguido de un adjetivo seguido de un sustantivo ;
3. Una frase verbal se compone de un verbo seguido de una frase 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 mediante una serie de sustituciones. ^{[ 102 ]} El proceso consiste en reemplazar los no terminales con un no terminal válido o un terminal válido . El proceso de sustitución se repite hasta que solo quedan terminales . Una oración válida es:

• oración
• frase nominal frase verbal
• artículo adjetivo sustantivo frase verbal
• el adjetivo sustantivo frase verbal
• la frase verbal sustantivo grande
• la frase verbal del gran felino
• el gran felino verbo frase nominal
• El gran felino come frase nominal
• el gran felino come artículo adjetivo sustantivo
• el gran felino come el adjetivo sustantivo
• El gato grande se come al sustantivo pequeño
• El gato grande se come al ratón pequeño.

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

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

Por lo tanto, es necesario un análisis semántico para describir correctamente el significado de una actividad de comer .

Un método para enumerar reglas de producción se denomina forma Backus-Naur (BNF). ^{[ 103 ]} La BNF describe la sintaxis de un lenguaje y tiene su propia sintaxis . Esta definición recursiva es un ejemplo de metalenguaje . ^{[ 98 ]} La sintaxis de la BNF incluye:

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

Utilizando BNF, un subconjunto del idioma inglés puede tener esta lista de reglas de producción :

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

Utilizando BNF, un entero con signo tiene la siguiente lista de reglas de producción : ^{[ 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 

Observe la regla de producción recursiva:

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

Esto permite un número infinito de posibilidades. Por lo tanto, es necesario un sistema semántico para describir la limitación del número de dígitos.

Observe la posibilidad de 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 necesario un lenguaje semántico 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 ]}

El analista de sistemas tiene el objetivo de 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 del resultado. ¿El resultado es útil para la toma de decisiones?
2. La precisión del resultado. ¿Refleja la situación real?
3. El formato de la salida. ¿La salida es fácil de entender?
4. La velocidad de respuesta. La información sensible al tiempo es importante al comunicarse con el cliente en tiempo real.

El logro de los objetivos de rendimiento debe equilibrarse con todos los costos, incluidos: ^{[ 109 ]}

1. Costes de desarrollo.
2. La singularidad tiene un precio. Un sistema reutilizable puede resultar caro. Sin embargo, podría ser preferible a un sistema de uso limitado.
3. Costes de hardware.
4. Costes operativos.

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

El modelo de cascada es una implementación de un proceso de desarrollo de sistemas . ^{[ 111 ]} Como lo indica 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 consiste en 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 se extiende durante toda la vida útil del sistema. Es posible que se requieran cambios en el sistema después de su implementación. ^{[ 113 ]} Pueden existir fallas, incluyendo fallas de especificación, de diseño o de codificación. Es posible que se requieran mejoras. Puede ser necesaria la adaptación para reaccionar a 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 ser completados por un solo programador. ^{[ 114 ]} Sin embargo, agregar programadores a un proyecto puede no acortar el tiempo de finalización. En cambio, puede disminuir la calidad del sistema. ^{[ 114 ]} Para ser efectivos, 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 manera significativa y efectiva. ^{[ 114 ]}

Los programadores informáticos pueden estar programando en pequeño : programando 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 estar programando en grande : programando módulos de manera que se acoplen eficazmente entre sí. ^{[ 115 ]} La programación en 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 en conjunto se identifican por 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 operació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 formar parte del nombre. ^{[ 117 ]} Por ejemplo, function compute_square_root( x )o son nombres de módulo apropiados. Sin embargo, no lo es.function compute_square_root_integer( i : integer )function compute_square_root_by_division( x )

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.

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 entre sí. Por ejemplo, function read_sales_record_print_next_line_convert_to_float(). La cohesión coincidente se produce en la práctica si la administración impone reglas absurdas. Por ejemplo, "Cada módulo tendrá entre 35 y 50 instrucciones ejecutables". ^{[ 119 ]}
• Cohesión lógica: Un módulo tiene cohesión lógica si dispone de 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 informacional : Un módulo posee cohesión informacional si realiza múltiples funciones, pero cada función tiene sus propios puntos de entrada y salida. Además, las funciones comparten la misma estructura de datos. Las clases orientadas a objetos operan a este nivel.
• Cohesión funcional : un módulo posee cohesión funcional si logra un único objetivo trabajando únicamente con variables locales. Además, puede ser reutilizable 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 sello : Un módulo tiene acoplamiento de sello si se modifica un elemento de una estructura de datos pasada como parámetro. Las clases orientadas a objetos funcionan a este nivel.
• Acoplamiento de datos : Un módulo tiene acoplamiento de datos si todos sus parámetros de entrada son necesarios y ninguno de ellos se modifica. 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 del 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 a nivel ejecutable o a 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 apunte hacia afuera para representar su único objeto de salida. (Opcionalmente, una flecha de excepción adicional apunta hacia afuera). Una cadena de óvalos representará 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 ]}

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 software de planificación de recursos empresariales , gestión de relaciones con el cliente y gestión de la cadena de suministro .

Las aplicaciones empresariales pueden desarrollarse internamente como software propietario único . ^{[ 124 ]} Alternativamente, pueden adquirirse como software comercial . El software adquirido 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 realizarse con el proveedor original del software o con un desarrollador externo. ^{[ 125 ]}

Las ventajas potenciales del software interno son que las características y los informes pueden desarrollarse 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 una nueva iniciativa de un competidor o implementar un requisito del cliente o proveedor. ^{[ 128 ]} Una fusión o adquisición puede requerir cambios en el software empresarial. Las desventajas potenciales del software interno son que los costos de tiempo y recursos pueden ser elevados. ^{[ 124 ]} Además, pueden presentarse riesgos relacionados con las características y el rendimiento.

Las ventajas potenciales del software comercial son que los costos iniciales son identificables, que se satisfacen las necesidades básicas y que su rendimiento y confiabilidad tienen un historial comprobado. ^{[ 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 ]}

Un sistema operativo es el software de bajo nivel que soporta las funciones básicas de una computadora, como la planificación de procesos y el control de 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 finalizada la ejecución, la salida podía imprimirse o perforarse en cinta de papel o tarjetas para su posterior procesamiento. ^{[ 30 ]} En la mayoría de los casos, el programa no funcionaba. El programador entonces observaba las luces de la consola y manipulaba los interruptores. Si tenía menos suerte, se imprimía la memoria para su posterior estudio. En la década de 1960, los programadores redujeron el tiempo perdido automatizando el trabajo del operador. Un programa llamado sistema operativo se mantenía en la computadora en todo momento. ^{[ 130 ]}

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

Programa del núcleo

El objetivo principal del núcleo es gestionar los recursos limitados de un ordenador:

• El programa del núcleo debe realizar la planificación de procesos , ^{[ 132 ]} también conocida como cambio de contexto . El núcleo crea un bloque de control de procesos cuando se selecciona un programa informático 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 interrumpe 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 núcleo debe realizar la gestión de la memoria .

• Cuando el núcleo carga inicialmente un ejecutable en la memoria, divide el espacio de direcciones lógicamente 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 virtual . La tabla de región maestra se utiliza para determinar dónde se encuentra su contenido 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 de programación almacena instrucciones de máquina. Dado que las instrucciones de máquina no cambian, la región de programación puede ser compartida por muchos procesos del mismo ejecutable. ^{[ 133 ]}
• Para ahorrar tiempo y memoria, el núcleo puede cargar solo bloques de instrucciones de ejecución desde la unidad de disco, no el archivo de ejecución 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 fallo de página . ^{[ 134 ]} En ese caso, el núcleo accede a la unidad de gestión de memoria para llenar 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 usar la memoria, puede solicitar que se libere . Si el proceso finaliza sin solicitar la liberación de toda la memoria asignada, el núcleo realiza la recolección de basura para liberarla.
• El núcleo también garantiza que un proceso solo acceda a su propia memoria, y no a la del núcleo ni a la 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 gestionar los 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 simultáneamente.
• 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 hacia el sistema de destino.
• El programa del núcleo debería proporcionar funciones a nivel de sistema para que los programadores las utilicen. ^{[ 137 ]}
  • Los programadores acceden a los archivos mediante una interfaz relativamente sencilla que, a su vez, ejecuta una interfaz de entrada/salida de bajo nivel relativamente compleja. Esta interfaz de bajo nivel incluye la creación de archivos, descriptores de archivos , búsqueda de archivos, lectura física y 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 compleja.
  • Los programadores realizan operaciones aritméticas 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 compleja. ^{[ 138 ]}
• El programa del núcleo debe proporcionar un canal de comunicación entre los procesos en ejecución. ^{[ 139 ]} Para un sistema de software grande, 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 lenguaje ensamblador ; sin embargo, los sistemas operativos modernos suelen escribirse en lenguajes de alto nivel como C , Objective-C y Swift . ^{[ m ]}

Una utilidad es un programa que facilita la administración del sistema y la ejecución del software. Un sistema operativo suele proporcionar utilidades para comprobar el hardware, como el almacenamiento, la memoria, los altavoces y las impresoras. ^{[ 140 ]} Una utilidad puede optimizar el rendimiento de un dispositivo de almacenamiento. Las utilidades del sistema supervisan el rendimiento del hardware y de la red y pueden activar una alerta cuando una métrica está fuera del rango nominal. ^{[ 141 ]} Una utilidad puede comprimir archivos para reducir el espacio de almacenamiento y el tiempo de transmisión de la red. ^{[ 140 ]} Una utilidad puede ordenar y fusionar conjuntos de datos ^{[ 141 ]} o detectar virus informáticos . ^{[ 141 ]}

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

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

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

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

Las instrucciones de microcódigo son mnemónicos que los programadores pueden usar para ejecutar funciones de lógica digital en lugar de formarlas en álgebra binaria. Se almacenan en la memoria de control de una unidad central de procesamiento (CPU) . ^{[ 147 ]} Estas instrucciones a nivel de hardware mueven los datos a lo largo de la ruta de datos .

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

Las instrucciones para realizar operaciones aritméticas se transmiten a través de una unidad aritmético-lógica (ALU). ^{[ 150 ]} La ALU cuenta con circuitos para realizar operaciones elementales como sumar, desplazar y comparar números enteros. Al combinar y procesar estas operaciones elementales en bucle a través de la ALU, la CPU realiza sus operaciones aritméticas complejas.

Las instrucciones de microcódigo transfieren datos entre la CPU y el controlador de memoria . Las instrucciones de microcódigo del controlador de memoria manipulan dos registros . El registro de direcciones de memoria se utiliza para acceder a la dirección de cada celda de memoria. El registro de datos de memoria se utiliza para establecer y leer el contenido de cada celda. ^{[ 151 ]}