Tabla de control

Una tabla de control es una estructura de datos de tabla (es decir, una matriz de registros ) que se utiliza para dirigir el flujo de control de un programa informático . El software que utiliza una tabla de control se denomina software basado en tablas . ^{[ 1 ]}^{[ 2 ]} Una tabla de control codifica tanto los parámetros de una expresión condicional como una referencia a una función . Un intérprete procesa una tabla evaluando la expresión condicional para los datos de entrada e invocando la función seleccionada. El uso de una tabla de control puede reducir la necesidad de código repetitivo que implementa la misma lógica.

En general, la asignación de parámetros de entrada puede realizarse mediante cualquier estructura de datos. Una estructura de datos común es la tabla de búsqueda , que ofrece un rendimiento relativamente alto, pero también un consumo de memoria considerable. Un array asociativo puede minimizar el uso de memoria a costa de un mayor tiempo de búsqueda.

La forma en que se referencia el comportamiento asociado varía. Algunos lenguajes proporcionan una referencia directa a la función (es decir, un puntero ) que permite invocarla directamente, mientras que otros no. Algunos lenguajes permiten saltar a una ubicación específica (es decir, una etiqueta ). Como alternativa, cualquier lenguaje permite asignar una entrada a un índice que luego permite acceder a una parte específica del código.

Una tabla de control se usa frecuentemente como parte de un algoritmo de nivel superior. Puede controlar el bucle principal de un programa orientado a eventos . Un uso relativamente avanzado son las instrucciones para una máquina virtual , similar al código de bytes , pero generalmente con operaciones implícitas en la estructura de la tabla en lugar de codificadas en los datos de la misma.

Estructura de datos

Una tabla puede estructurarse de diversas maneras. Puede tener una o varias dimensiones y ser de longitud fija o variable . Su estructura puede ser similar a la de una matriz asociativa multimapa , donde un valor de datos (o una combinación de valores) se asigna a una o más funciones. A menudo, esta estructura permite que los datos tabulares sean portátiles entre plataformas informáticas , siempre que exista un intérprete compatible en cada una.

Función hash trivial

Una implementación relativamente sencilla consiste en una matriz dispersa unidimensional de valores. El espacio de índices está completamente cubierto por la matriz, de modo que la búsqueda implica indexar la matriz mediante el valor de entrada, y se encuentra un valor incluso para un índice que no se pretende utilizar; esto evita un error que podría ocurrir para un valor de índice no utilizado. La búsqueda se realiza en tiempo constante , sin necesidad de buscar. En la mayoría de las arquitecturas , esto se puede lograr en dos o tres instrucciones de máquina . Esta técnica se conoce como " función hash trivial " o, cuando se utiliza específicamente para tablas de ramificación, " doble despacho ".

Para que sea factible, el rango de valores del índice debe ser relativamente pequeño. En el ejemplo siguiente, la tabla de control está indexada por valor ASCII, por lo que tiene 256 entradas (una entrada por cada valor ASCII); las entradas omitidas se muestran como '...'. Solo los valores de las letras A, D, M y S son importantes. Todos los demás valores son irrelevantes y se establecen en 0. Un índice de dos bytes requeriría un mínimo de 65 536 entradas para gestionar todas las posibilidades de entrada , lo que podría consumir más memoria de la que justifica el valor que proporciona.

En la programación basada en autómatas y el procesamiento de transacciones pseudoconversacionales , si el número de estados distintos del programa es pequeño, se puede utilizar una variable de control de "secuencia densa" para dictar de manera eficiente todo el flujo del bucle principal del programa.

Tabla de ramificación

Una tabla de ramificación es una matriz unidimensional de instrucciones de salto/ramificación en código máquina para realizar una ramificación múltiple a una etiqueta de programa cuando se accede a ella mediante una ramificación inmediatamente anterior e indexada. A veces, un compilador optimizador la genera para ejecutar una instrucción switch , siempre que el rango de entrada sea pequeño y denso, con pocos huecos. ^[³^] (como se creó en el ejemplo de matriz anterior)

Aunque bastante compactas —en comparación con las múltiples Ifinstrucciones equivalentes—, las instrucciones de salto aún presentan cierta redundancia, ya que el código de operación y la máscara de código de condición del salto se repiten junto con los desplazamientos del salto. Se pueden construir tablas de control que contengan únicamente los desplazamientos a las etiquetas del programa para superar esta redundancia (al menos en lenguajes ensamblador), lo que requiere una sobrecarga de tiempo de ejecución mínima en comparación con una tabla de salto convencional.

Tabla de decisiones

A menudo, una tabla de control implementa una tabla de decisiones , que, al igual que una tabla de control, contiene proposiciones (a menudo implícitas) y una o más acciones asociadas.

Una tabla de control puede funcionar como una instrucción switch o, de forma más general, como una estructura if-then-else anidada que incluye predicados lógicos (utilizando condiciones booleanas AND / OR ) para cada caso. Dicha tabla de control proporciona una implementación independiente del lenguaje para lo que, de otro modo, sería una estructura dependiente del lenguaje. La tabla encapsula la esencia de un programa, despojada de la sintaxis del lenguaje de programación y de los aspectos dependientes de la plataforma, y condensada en datos y lógica implícita. El significado de la tabla incluye operaciones implícitas en lugar de ser explícito, como en un paradigma de programación más típico .

Normalmente, una tabla de control bidimensional contiene pares valor/acción y, además, puede incluir operadores e información de tipo , como la ubicación, el tamaño y el formato de los datos de entrada o salida, así como si se requiere conversión de datos . La tabla puede contener índices o punteros relativos o absolutos a primitivas o funciones genéricas o personalizadas que se ejecutarán en función de otros valores de la fila.

El tipo de valores que se utilizan en una tabla de control depende del lenguaje de programación empleado por el intérprete. El lenguaje ensamblador ofrece la mayor variedad de tipos de datos , incluyendo código máquina para la búsqueda de valores. Normalmente, una tabla de control contiene valores para cada clase de entrada coincidente, junto con un puntero correspondiente a una función de acción. En el caso de un lenguaje sin soporte para punteros , la tabla puede codificar un índice que implica un valor de desplazamiento, el cual puede utilizarse para lograr el mismo efecto que un puntero.

Almacenamiento

Una tabla de control puede almacenarse de diversas maneras. Puede almacenarse como parte de un programa, por ejemplo, como una variable estática . Puede almacenarse en el sistema de archivos , por ejemplo, como un archivo plano o en una base de datos . También puede generarse dinámicamente por el programa. Para mayor eficiencia, la tabla debe residir en la memoria del programa cuando el intérprete la utiliza.

Intérprete

Un intérprete de tabla de control ejecuta las operaciones según los parámetros de entrada seleccionados. La tabla y el comportamiento resultante en tiempo de ejecución pueden modificarse sin necesidad de modificar el intérprete. Si bien un intérprete puede requerir mantenimiento para modificar su comportamiento, lo ideal es que esté diseñado para admitir funcionalidades futuras mediante cambios en la tabla.

Las funciones de controlador suelen estar codificadas en el mismo lenguaje que el intérprete, pero podrían estar en otro lenguaje si existe un mecanismo de enlace de llamadas entre lenguajes adecuado. La elección del lenguaje para el intérprete y las funciones de controlador generalmente depende de la portabilidad requerida entre distintas plataformas . Puede haber varias versiones del intérprete para garantizar la portabilidad . Un puntero a la tabla de control subordinada puede sustituir opcionalmente a un puntero a función en la columna de acción si el intérprete admite esta construcción. Esto representa una caída condicional a un nivel lógico inferior, imitando la programación estructurada .

Consideraciones de rendimiento

Aunque el uso de una tabla de control implica el coste de desarrollo y el tamaño de despliegue de un intérprete, al separar (encapsular) el código ejecutable de la lógica expresada en la tabla, se facilita su uso para cumplir su función. Esto se puede observar en una aplicación de hoja de cálculo, donde el software subyacente convierte de forma transparente fórmulas lógicas complejas de la manera más eficiente posible para mostrar los resultados.

Los ejemplos que se presentan a continuación se han seleccionado en parte para ilustrar las posibles mejoras de rendimiento que no solo compensan significativamente el nivel adicional de abstracción, sino que también optimizan un código que, de otro modo, podría ser menos eficiente, menos mantenible y más extenso. Si bien los ejemplos se basan en un lenguaje ensamblador de bajo nivel y en el lenguaje C , en ambos casos se observa que se requieren muy pocas líneas de código para implementar el enfoque de tabla de control y, sin embargo, se pueden lograr mejoras de rendimiento muy significativas en tiempo constante , reducir la codificación repetitiva y mejorar la claridad, en comparación con las construcciones de lenguajes de programación convencionales y verbosos .

Ejemplos

General

CT1 es una tabla de control que funciona como una simple tabla de búsqueda . La primera columna representa el valor de entrada que se va a comprobar (mediante una condición implícita 'SI entrada = x') y, si es así, se ejecuta la acción correspondiente en la segunda columna. Es similar a una bifurcación múltiple con retorno, una forma de despacho dinámico .

El siguiente ejemplo ilustra cómo se puede lograr un efecto similar en un lenguaje que no admite definiciones de punteros en estructuras de datos, pero sí admite ramificaciones indexadas a una función, contenida en un array ( basado en 0 ) de punteros a funciones. La tabla (CT2) se utiliza para extraer el índice (de la segunda columna) del array de punteros (CT2P). Si no se admiten arrays de punteros, se puede usar una instrucción SWITCH o equivalente para modificar el flujo de control a una de una secuencia de etiquetas de programa (por ejemplo: case0, case1, case2, case3, case4), que luego procesan la entrada directamente o realizan una llamada (con retorno) a la función correspondiente.

Como en los ejemplos anteriores, es posible traducir de manera eficiente los posibles valores de entrada ASCII (A, S, M, D) a un índice de matriz de punteros sin utilizar realmente una búsqueda en tabla, pero aquí se muestra como una tabla para mantener la coherencia con el primer ejemplo.

Se puede usar una tabla de control bidimensional para probar múltiples condiciones o realizar varias acciones. Cada acción puede incluir un puntero a otra tabla de control subordinada. En el ejemplo sencillo que se muestra a continuación, se ha incorporado una condición "OR" implícita como columna adicional (para manejar entradas en minúsculas; sin embargo, en este caso, también se podría haber resuelto agregando una entrada para cada carácter en minúscula con el mismo identificador de función que los caracteres en mayúscula). También se incluye una columna adicional para contabilizar los eventos de ejecución para cada entrada a medida que ocurren.

Las entradas de la tabla de control son entonces mucho más similares a las sentencias condicionales en los lenguajes de programación procedimentales , pero, fundamentalmente, sin que estén presentes las sentencias condicionales reales (que dependen del lenguaje) (es decir, las instrucciones) (el código genérico está físicamente en el intérprete que procesa las entradas de la tabla, no en la tabla misma, que simplemente incorpora la lógica del programa a través de su estructura y valores).

En tablas como estas, donde una serie de entradas similares definen toda la lógica, un número o puntero de entrada puede reemplazar eficazmente un contador de programa en programas más convencionales y puede reiniciarse en una "acción", también especificada en la entrada de la tabla. El ejemplo siguiente (CT4) muestra cómo extender la tabla anterior para incluir una entrada "siguiente" (y/o incluir una función "alter flow" ( salto )) puede crear un bucle . (Este ejemplo no es la forma más eficiente de construir una tabla de control de este tipo, pero, al demostrar una "evolución" gradual a partir de los primeros ejemplos anteriores, muestra cómo se pueden usar columnas adicionales para modificar el comportamiento). La quinta columna demuestra que se puede iniciar más de una acción con una sola entrada de tabla; en este caso, una acción que se realizará después del procesamiento normal de cada entrada (los valores "-" significan "sin condiciones" o "sin acción").

La programación estructurada o el código "sin Goto" (que incorpora el equivalente a las estructuras de bucle " do-while " o " for ") también se pueden implementar con estructuras de tablas de control diseñadas y con sangría adecuadas.

lenguaje C

El siguiente ejemplo en C utiliza dos arreglos que, en conjunto, forman una estructura de datos de tabla. El opsarreglo es un arreglo unidimensional de búsqueda lineal simple, que se utiliza para obtener el índice del elemento que coincide con la entrada op. El handler_labelsarreglo contiene direcciones de etiquetas a las que saltar. El bucle compara cada opselemento opy, si coinciden, invoca la gotofunción para la etiqueta en el mismo índice que el opselemento encontrado.

static const char ops [ 4 ] = { "A" , "S" , "M" , "D" };static const void * handler_labels [ 4 ] = { && Sumar , && Restar , && Multiplicar , && Dividir };para ( int i = 0 ; i < sizeof ( ops ); i ++ ) {si ( op == ops [ i ]) {ir a * handler_labels [ i ];}}

Esto se ejecutaría más rápido si se usara una tabla de 256 bytes para traducir la entrada ASCII ( op) a un índice sin búsqueda. Se ejecutaría en tiempo constante para todos los valores de op. Si un handler_labelselemento contuviera el nombre de una función en lugar de una etiqueta, el salto podría reemplazarse con una llamada a función dinámica, eliminando la estructura switch gotopero disminuyendo el rendimiento en tiempo de ejecución.

static const void * handler_labels [] = { && Predeterminado , && Sumar , && Restar , && Multiplicar , && Dividir };static const char handler_label_index_by_op [ 256 ] = {0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 1 , 0 , 0 , 4 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 3 , 0 , 0 ,0 , 0 , 0 , 2 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ,0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0};size_t i = handler_label_index_by_op ( x );ir a * handler_labels [ i ];

Clasificación basada en tablas

En el campo especializado de la tarificación de telecomunicaciones (que se ocupa de determinar el coste de una llamada concreta), las técnicas de tarificación basadas en tablas ilustran el uso de tablas de control en aplicaciones donde las reglas pueden cambiar con frecuencia debido a las fuerzas del mercado. En muchos casos, las tablas que determinan las tarifas pueden ser modificadas con poca antelación por personas sin conocimientos de programación. ^{[ 4 ]}^{[ 5 ]}

Si los algoritmos no están preintegrados en el intérprete (y, por lo tanto, requieren una interpretación adicional en tiempo de ejecución de una expresión almacenada en la tabla), se conoce como "clasificación basada en reglas" en lugar de clasificación basada en tablas (y, en consecuencia, consume una sobrecarga significativamente mayor).

hojas de cálculo

Una hoja de cálculo puede utilizarse como una tabla de control bidimensional, donde las celdas no vacías representan datos para el programa subyacente (el intérprete). Las celdas que contienen fórmulas suelen ir precedidas de un signo igual e indican un tipo especial de entrada de datos que determina el procesamiento de otras celdas referenciadas, modificando el flujo de control dentro del intérprete. Es precisamente la externalización de fórmulas del intérprete lo que identifica claramente tanto a las hojas de cálculo como al ejemplo de "calificación basada en reglas" citado anteriormente, como casos fácilmente identificables del uso de tablas de control por parte de personas sin conocimientos de programación.

paradigma de programación

Si la técnica de tablas de control pudiera considerarse perteneciente a algún paradigma de programación en particular , la analogía más cercana sería la programación basada en autómatas o la programación reflexiva (una forma de metaprogramación , ya que se podría decir que las entradas de la tabla modifican el comportamiento del intérprete). Sin embargo, el intérprete y las funciones pueden programarse utilizando cualquiera de los paradigmas disponibles o incluso una combinación de ellos. La tabla en sí puede ser esencialmente una colección de valores de " datos brutos " que ni siquiera necesitan compilarse y que pueden leerse desde una fuente externa (excepto en implementaciones específicas, dependientes de la plataforma, que utilizan punteros de memoria directamente para una mayor eficiencia).

Máquina virtual

Una tabla de control bidimensional es similar al código ejecutable intermedio (es decir, bytecode ) que se ejecuta en una máquina virtual , ya que requiere un intérprete dependiente de la plataforma para llevar a cabo una ejecución que está determinada en gran medida por el contenido de la tabla. También presenta similitudes con el Lenguaje Intermedio Común (CIL) en cuanto a la creación de un conjunto de instrucciones intermedias comunes e independientes de la plataforma, pero, a diferencia de CIL, no pretende ser un recurso común para otros lenguajes. El código P también puede considerarse una implementación similar, aunque anterior, con orígenes que se remontan a 1966.

Obtención de instrucciones

Cuando se utiliza una tabla de control bidimensional para determinar el flujo del programa, la función normal del contador de programa "hardware" se simula eficazmente mediante un puntero a la primera (o siguiente) entrada de la tabla o bien un índice a la misma. La "recuperación" de la instrucción implica decodificar los datos de esa entrada de la tabla, sin necesidad de copiar primero todos o algunos de los datos que contiene. Los lenguajes de programación que pueden usar punteros tienen la doble ventaja de que implican menos sobrecarga , tanto en el acceso al contenido como en el avance del contador para apuntar a la siguiente entrada de la tabla después de la ejecución. El cálculo de la siguiente dirección de "instrucción" (es decir, la siguiente entrada de la tabla) puede incluso realizarse como una acción adicional opcional para cada entrada individual de la tabla, lo que permite bucles o instrucciones de salto en cualquier etapa.

Ejecución de la tabla de control de supervisión

El programa intérprete puede guardar opcionalmente el contador del programa (y otros detalles relevantes según el tipo de instrucción) en cada etapa para registrar un rastro completo o parcial del flujo real del programa con fines de depuración , detección de puntos críticos , análisis de cobertura de código y análisis de rendimiento (véanse los ejemplos CT3 y CT4 anteriores).

Ventajas

Claridad: Las tablas de información son omnipresentes y, en su mayoría, son comprendidas de forma intuitiva incluso por el público en general (especialmente las tablas de diagnóstico de fallos en las guías de productos ).

Portabilidad: puede diseñarse para ser independiente del idioma y la plataforma , excepto para el intérprete.

Flexibilidad: Capacidad para ejecutar primitivas o funciones de forma transparente y diseñarse a medida para adaptarse al problema.

Compacidad: La tabla suele mostrar el emparejamiento condición/acción uno al lado del otro (sin las dependencias habituales de implementación de plataforma/lenguaje), lo que a menudo también resulta en un tamaño de archivo binario reducido debido a una menor duplicación de instrucciones, un tamaño de código fuente reducido debido a la eliminación de sentencias condicionales y velocidades de carga (o descarga) del programa reducidas.

Mantenibilidad: Las tablas suelen reducir el número de líneas de origen que deben mantenerse en comparación con las comparaciones múltiples.

Localidad de referencia: Las estructuras de tabla compactas dan como resultado que las tablas permanezcan en la caché.

Reutilización de código: El intérprete suele ser reutilizable. Con frecuencia, se puede adaptar a nuevas tareas de programación utilizando la misma técnica y puede crecer de forma orgánica, convirtiéndose, en efecto, en una biblioteca estándar de funciones probadas y contrastadas, controladas por las definiciones de las tablas.

Eficiencia: Es posible la optimización de todo el sistema. Cualquier mejora en el rendimiento del intérprete suele mejorar también el de todas las aplicaciones que lo utilizan (véanse los ejemplos en 'CT1' más arriba).

Extensible: new instructions can be added by extending the interpreter

Opcionalmente:

El intérprete puede ser introspectivo y "autooptimizarse " utilizando métricas de tiempo de ejecución recopiladas dentro de la propia tabla (ver CT3 y CT4, con entradas que podrían ordenarse periódicamente por recuento descendente). Opcionalmente, el intérprete también puede elegir dinámicamente la técnica de búsqueda más eficiente a partir de las métricas recopiladas en tiempo de ejecución (por ejemplo, tamaño de la matriz, rango de valores, ordenados o no ordenados).

Despacho dinámico : las funciones comunes se pueden precargar y las menos comunes se pueden recuperar solo en el primer encuentro para reducir el uso de memoria . Para ello, se puede emplear la memorización en tabla .

El intérprete puede tener funciones de depuración, rastreo y monitorización integradas, que luego se pueden activar o desactivar a voluntad según el modo de prueba o "en vivo".

Las tablas de control se pueden crear "sobre la marcha" (según la información que introduzca el usuario o a partir de parámetros) y luego ser ejecutadas por el intérprete (sin necesidad de generar código literalmente).

Desventajas

Capacitación: Los programadores de aplicaciones no suelen estar capacitados para producir soluciones genéricas.

Sobrecarga computacional: cierto aumento debido al nivel adicional de indirección causado por las instrucciones virtuales que deben ser "interpretadas" (sin embargo, esto generalmente puede ser compensado con creces por un intérprete genérico bien diseñado que aprovecha al máximo las técnicas eficientes de traducción directa, búsqueda y prueba condicional que de otro modo no se habrían utilizado).

Complejidad: Las expresiones complejas no siempre se pueden usar directamente en las entradas de las tablas de datos para fines de comparación. Sin embargo, estos valores intermedios se pueden calcular previamente dentro de una función y sus valores se pueden usar en las entradas condicionales de la tabla. Alternativamente, una función puede realizar la prueba condicional compleja completa (como una "acción" incondicional) y, al establecer un indicador de verdad como resultado, se puede probar en la siguiente entrada de la tabla. Véase el teorema del programa estructurado .

Citas

La ramificación múltiple es una técnica de programación importante que, con demasiada frecuencia, se reemplaza por una secuencia ineficiente de condicionales. Peter Naur me escribió recientemente que considera el uso de tablas para controlar el flujo del programa como una idea básica de la informática que casi ha caído en el olvido; pero espera que pronto vuelva a estar de moda. Es la clave de la eficiencia en todos los mejores compiladores que he estudiado.

— Donald Knuth , Programación estructurada con sentencias go to

Existe otra forma de ver un programa escrito en lenguaje interpretado. Puede considerarse como una serie de llamadas a subrutinas, una tras otra. De hecho, dicho programa puede expandirse en una larga secuencia de llamadas a subrutinas y, a la inversa, dicha secuencia generalmente puede empaquetarse en un código fácilmente interpretable. Las ventajas de las técnicas interpretativas radican en la compacidad de la representación, la independencia de la máquina y la mayor capacidad de diagnóstico. A menudo, se puede escribir un intérprete de manera que el tiempo dedicado a la interpretación del código y a la bifurcación a la rutina apropiada sea insignificante.

— Donald Knuth , El arte de la programación informática, Volumen 1, 1997, página 202

El espacio necesario para representar un programa a menudo se puede reducir mediante el uso de intérpretes en los que las secuencias comunes de operaciones se representan de forma compacta. Un ejemplo típico es el uso de una máquina de estados finitos para codificar un protocolo complejo o un formato léxico en una tabla pequeña.

— Jon Bentley , Escritura de programas eficientes

Las tablas de salto pueden ser especialmente eficientes si se pueden omitir las pruebas de rango. Por ejemplo, si el valor de control es un tipo enumerado (o un carácter), entonces solo puede contener un pequeño rango fijo de valores y una prueba de rango es redundante siempre que la tabla de salto sea lo suficientemente grande como para manejar todos los valores posibles.

— David A. SPULER, Generación de código de compilador para sentencias de bifurcación múltiples como un problema de búsqueda estática

Los programas deben escribirse para que las personas los lean, y solo incidentalmente para que las máquinas los ejecuten.

— "Estructura e interpretación de programas informáticos", prefacio de la primera edición, Abelson & Sussman

Muéstrame tu diagrama de flujo y oculta tus tablas, y seguiré sin entenderlo. Muéstrame tus tablas, y normalmente no necesitaré tu diagrama de flujo; será obvio.

— "El hombre-mes mítico: ensayos sobre ingeniería de software", Fred Brooks

Véase también

Arquitectura centrada en bases de datos – Arquitectura de software
Pruebas basadas en datos : técnica de prueba de software
Pruebas basadas en palabras clave : metodología de pruebas de software
Código multihilo : programa cuyo código fuente consiste enteramente en llamadas a funciones.
Tabla de verdad : tabla matemática utilizada en lógica.

Notas

↑ Programas a partir de tablas de decisión , Humby, E., 2007, Macdonald, 1973... Biggerstaff, Ted J. Englewood Cliffs, NJ : Prentice-Hall ISBN 0-444-19569-6
↑ "Copia archivada" (PDF) . Archivado del original (PDF) el 10 de junio de 2016. Recuperado el 17 de mayo de 2016 .{{cite web}}: CS1 mantenimiento: copia archivada como título ( enlace )
↑ http://www.netrino.com/node/137
↑ Carl Wright, Service Level Corpo. (2002) Calificación basada en código de programa vs. basada en tablas vs. basada en reglas , Rating Matters número 12, 13 de noviembre de 2002 ISSN 1532-1886
↑ Brian E. Clauser, Melissa J. Margolis, Stephen G. Clyman, Linette P. Ross (1997) Desarrollo de algoritmos de puntuación automatizados para evaluaciones de desempeño complejas: una comparación de dos enfoques. Journal of Educational Measurement, vol. 34, n.° 2 (verano de 1997), págs. 141-161.

Referencias

Metodología basada en tablas de decisión
Programación estructurada con sentencias goto por Donald Knuth
Generación de código de compilador para sentencias de bifurcación múltiples como un problema de búsqueda estática (1994), por David A. Spuler.

Enlaces externos

La instrucción switch en Windows PowerShell describe extensiones a la instrucción switch estándar (proporcionando algunas características similares para controlar tablas).
Ejemplo de tabla de control en lenguaje "C" usando punteros , por Christopher Sawtell c1993, Departamento de Ciencias de la Computación, Universidad de Auckland.
Diseño basado en tablas. Archivado el 10 de junio de 2016 en Wayback Machine por Wayne Cunneyworth de DataKinetics.
De los requisitos a las tablas, al código y a las pruebas, por George Brooke.
Algunos comentarios sobre el uso de tablas de decisión ambiguas y su conversión a programas informáticos por PJH King y RG Johnson, Universidad de Londres, Londres, Reino Unido
Ambigüedad en las tablas de decisión de entrada limitada por PJH King
Conversión de tablas de decisión a programas informáticos mediante técnicas de máscara de reglas por PJH King
Análisis de generación de código de bifurcación múltiple mediante superoptimizador. Archivado el 27 de febrero de 2012 en la Wayback Machine, sección 3.9, página 16, índice.
Tablas de salto a través de arreglos de punteros a funciones en C/C++ Jones, Nigel. "Arreglos de punteros a funciones"Programación de sistemas embebidos, mayo de 1999."
Estadísticas de visitas a esta página correspondientes a diciembre de 2009.

Software de modelado con máquinas de estados finitos: un enfoque práctico.
Tablas de estados finitos para aplicaciones generales de programación informática. Enero de 1988, por Mark Leininger.
MSDN: Procesamiento de eventos basado en desencadenadores
Tabla de control en c2.com

[1] Programas a partir de tablas de decisión , Humby, E., 2007, Macdonald, 1973... Biggerstaff, Ted J. Englewood Cliffs, NJ : Prentice-Hall ISBN 0-444-19569-6

[2] "Copia archivada" (PDF) . Archivado del original (PDF) el 10 de junio de 2016. Recuperado el 17 de mayo de 2016 .{{cite web}}: CS1 mantenimiento: copia archivada como título ( enlace )

[3] ttp://www.netrino.com/node/137

[4] Carl Wright, Service Level Corpo. (2002) Calificación basada en código de programa vs. basada en tablas vs. basada en reglas , Rating Matters número 12, 13 de noviembre de 2002 ISSN 1532-1886

[5] Brian E. Clauser, Melissa J. Margolis, Stephen G. Clyman, Linette P. Ross (1997) Desarrollo de algoritmos de puntuación automatizados para evaluaciones de desempeño complejas: una comparación de dos enfoques. Journal of Educational Measurement, vol. 34, n.° 2 (verano de 1997), págs. 141-161.

[ 1 ]

[ 2 ]

[

[ 4 ]

[ 5 ]