Programación estructurada de Jackson

Ejemplo de un diagrama JSP.

programación estructurada de Jackson (JSP) es un método de programación estructurada desarrollado por el consultor de software británico Michael A. Jackson y descrito en su libro de 1975 Principles of Program Diseño. La técnica de JSP consiste en analizar las estructuras de datos de los archivos que un programa debe leer como entrada y producir como salida, y luego producir un diseño de programa basado en esas estructuras de datos, de modo que la estructura de control del programa maneje esas estructuras de datos de forma natural. e intuitiva.

JSP describe estructuras (tanto de datos como de programas) utilizando tres estructuras básicas: secuencia, iteración y selección (o alternativas). Estas estructuras se diagraman como (en efecto) una representación visual de una expresión regular.

Introducción

Michael A. Jackson desarrolló originalmente JSP en la década de 1970. Documentó el sistema en su libro de 1975 Principles of Program Design. En una charla de conferencia de 2001, proporcionó un análisis retrospectivo de las fuerzas impulsoras originales detrás del método y lo relacionó con los desarrollos posteriores de ingeniería de software. El objetivo de Jackson era hacer que los programas de procesamiento de archivos por lotes COBOL fueran más fáciles de modificar y mantener, pero el método se puede usar para diseñar programas para cualquier lenguaje de programación que tenga construcciones de control estructuradas: secuencia, iteración y selección (" si/entonces/si no...).

La programación estructurada de Jackson era similar a la programación estructurada de Warnier/Orr, aunque JSP consideraba estructuras de datos tanto de entrada como de salida, mientras que el método de Warnier/Orr se centraba casi exclusivamente en la estructura del flujo de salida.

Motivación por el método

En el momento en que se desarrolló JSP, la mayoría de los programas eran programas COBOL por lotes que procesaban archivos secuenciales almacenados en cinta. Un programa típico lee su archivo de entrada como una secuencia de registros, de modo que todos los programas tienen la misma estructura: un bucle principal único que procesa todos los registros del archivo, uno a la vez. Jackson afirmó que la estructura de este programa casi siempre era incorrecta y alentó a los programadores a buscar estructuras de datos más complejas. En el capítulo 3 de Principles of Program Design, Jackson presenta dos versiones de un programa, una diseñada con JSP y la otra con la estructura tradicional de bucle único. Aquí está su ejemplo, traducido de COBOL a Java. El propósito de estos dos programas es reconocer grupos de registros repetidos (líneas) en un archivo ordenado y generar un archivo de salida que enumere cada registro y la cantidad de veces que aparece en el archivo.

Esta es la versión tradicional de un solo ciclo del programa.

String línea;int Cuenta = 0;String firstLineOfGroup = nulo;// comenzar el bucle principalmientras ()línea = dentro.readLine()) ! nulo) {} si ()firstLineOfGroup == nulo Silencio !línea.iguales()firstLineOfGroup) {} si ()firstLineOfGroup ! nulo) {} Sistema.Fuera..println()firstLineOfGroup + " + Cuenta); } Cuenta = 0; firstLineOfGroup = línea; } Cuenta++;}si ()firstLineOfGroup ! nulo) {} Sistema.Fuera..println()firstLineOfGroup + " + Cuenta);}

Aquí hay una versión estilo JSP del mismo programa. Tenga en cuenta que (a diferencia del programa tradicional) tiene dos bucles, uno anidado dentro del otro. El ciclo externo procesa grupos de registros repetidos, mientras que el ciclo interno procesa los registros individuales de un grupo.

String línea;int numberOfLinesInGroup;línea = dentro.readLine();// comenzar el bucle exterior: proceso 1 grupomientras ()línea ! nulo) {} numberOfLinesInGroup = 0; String firstLineOfGroup = línea; // iniciar el bucle interior: proceso 1 registro en el grupo mientras ()línea ! nulo " línea.iguales()firstLineOfGroup) {} numberOfLinesInGroup++; línea = dentro.readLine(); } Sistema.Fuera..println()firstLineOfGroup + " + numberOfLinesInGroup);}

Jackson critica la versión tradicional de bucle único por no procesar la estructura del archivo de entrada (repetir grupos de registros que contienen registros individuales repetidos) de forma natural. Una señal de su diseño antinatural es que, para funcionar correctamente, se ve obligado a incluir un código especial para manejar el primer y último registro del archivo.

El método básico

JSP utiliza pasos semiformales para capturar la estructura existente de las entradas y salidas de un programa en la estructura del propio programa.

La intención es crear programas que sean fáciles de modificar durante su vida útil. La principal percepción de Jackson fue que los cambios en los requisitos suelen ser ajustes menores a las estructuras existentes. Para un programa construido utilizando JSP, las entradas, las salidas y las estructuras internas del programa coinciden, por lo que los pequeños cambios en las entradas y salidas deberían traducirse en pequeños cambios en el programa.

JSP estructura los programas en términos de cuatro tipos de componentes:

• operaciones fundamentales
• secuencias
• iteraciones
• selecciones

El método comienza describiendo las entradas de un programa en términos de los cuatro tipos de componentes fundamentales. Luego pasa a describir los resultados del programa de la misma manera. Cada entrada y salida se modela como un diagrama de estructura de datos (DSD) separado. Para hacer que JSP funcione para aplicaciones informáticas intensivas, como el procesamiento de señales digitales (DSP), también es necesario dibujar diagramas de estructura de algoritmos, que se centren en las estructuras de datos internas en lugar de las de entrada y salida.

Luego, las estructuras de entrada y salida se unifican o fusionan en una estructura de programa final, conocida como diagrama de estructura de programa (PSD). Este paso puede implicar la adición de una pequeña cantidad de estructura de control de alto nivel para casar las entradas y salidas. Algunos programas procesan toda la entrada antes de generar cualquier salida, mientras que otros leen un registro, escriben un registro e iteran. Dichos enfoques tienen que ser capturados en el PSD.

El PSD, que es independiente del lenguaje, se implementa luego en un lenguaje de programación. JSP está orientado a la programación a nivel de estructuras de control, por lo que los diseños implementados utilizan solo operaciones, secuencias, iteraciones y selecciones primitivas. JSP no se usa para estructurar programas a nivel de clases y objetos, aunque puede ayudar a estructurar el flujo de control dentro de los métodos de una clase.

JSP utiliza una notación de diagramación para describir la estructura de entradas, salidas y programas, con elementos de diagrama para cada uno de los tipos de componentes fundamentales.

Una operación simple se dibuja como un cuadro.

Una operación

Una secuencia de operaciones se representa mediante cuadros conectados con líneas. En el siguiente ejemplo, A es una secuencia que consta de las operaciones B, C y D.

Una secuencia

Una iteración se representa de nuevo con cuadros unidos. Además, la operación iterada tiene una estrella en la esquina superior derecha de su cuadro. En el siguiente ejemplo, A es una iteración de cero o más invocaciones de la operación B.

Una iteración

La selección es similar a una secuencia, pero con un círculo dibujado en la esquina superior derecha de cada operación opcional. En el ejemplo, A es una selección de una y sólo una de las operaciones B, C o D.

Una selección

Tenga en cuenta que en los diagramas anteriores, es el elemento A el que es la secuencia o iteración, no los elementos B, C o D (que en los diagramas anteriores son todos elementales). Jackson da la 'regla de mirar hacia abajo' para determinar qué es un elemento, es decir, mirar los elementos debajo de un elemento para averiguar qué es.

Un ejemplo resuelto

Como ejemplo, así es como un programador de JSP diseñaría y codificaría un codificador de longitud de ejecución. Un codificador de longitud de ejecución es un programa cuya entrada es un flujo de bytes que se puede ver como si ocurriera en ejecuciones, donde una ejecución consta de una o más ocurrencias de bytes del mismo valor. La salida del programa es un flujo de pares de bytes, donde cada par de bytes es una descripción comprimida de una ejecución. En cada par, el primer byte es el valor del byte repetido en una ejecución y el segundo byte es un número que indica la cantidad de veces que ese valor se repitió en la ejecución. Por ejemplo, una serie de ocho apariciones de la letra "A" en el flujo de entrada ("AAAAAAAA") produciría "A8" como un par de bytes en el flujo de salida. Los codificadores de longitud de ejecución se utilizan a menudo para comprimir mapas de bits de forma tosca.

Con JSP, el primer paso es describir las estructuras de datos de los flujos de entrada de un programa. El programa tiene solo un flujo de entrada, que consta de cero o más ejecuciones del mismo valor de byte. Aquí está el diagrama de estructura de datos JSP para el flujo de entrada.

El segundo paso es describir la estructura de datos de salida, que en este caso consta de cero o más iteraciones de pares de bytes.

El siguiente paso es describir las correspondencias entre los componentes de las estructuras de entrada y salida.

El próximo paso es usar las correspondencias entre las dos estructuras de datos para crear una estructura de programa que sea capaz de procesar la estructura de datos de entrada y producir la estructura de datos de salida. (A veces, esto no es posible. Consulte la discusión sobre choques de estructuras, a continuación).

Una vez que la estructura del programa está terminada, el programador crea una lista de las operaciones computacionales que el programa debe realizar, y el diagrama de la estructura del programa se completa colgando esas operaciones fuera de los componentes estructurales apropiados.

1. leer un byte
2. recuerda byte
3. sistema contador a cero
4. contador de aumento
5. producción recordada por
6. contador de productos

Además, en esta etapa se enumeran y agregan al diagrama de estructura del programa las condiciones de las iteraciones (bucles) y las selecciones (if-then-else o declaraciones case).

1. mientras hay más bytes
2. mientras hay más bytes y este byte es el mismo que el primer byte de la carrera y el conteo todavía encaja en un byte

Una vez que el diagrama está terminado, se puede traducir a cualquier lenguaje de programación que se esté utilizando. Aquí hay una traducción a C.

#include Identificado.h#include ■stdlib.hint principal()int argc, char *argv[]){} int c; int first_byte; int Cuenta; c = getchar(); /* obtener el primer byte */ mientras ()c ! EOF) {} /* procesar el primer byte en la carrera */ first_byte = c; Cuenta = 1; c = getchar(); /* obtener el siguiente byte */ /* procesar los bytes sucesores en la carrera */ mientras ()c ! EOF " c == first_byte " Cuenta . 255) {} /* proceso de un byte del mismo valor */ Cuenta++; c = getchar(); /* obtener el siguiente byte */ } putchar()first_byte); putchar()Cuenta); } retorno EXIT_SUCCESS;}

Técnicas para manejar problemas de diseño difíciles

En Principles of Program Design, Jackson reconoció situaciones que planteaban tipos específicos de problemas de diseño y proporcionó técnicas para manejarlos.

Una de estas situaciones es un caso en el que un programa procesa dos archivos de entrada, en lugar de uno. En 1975, uno de los "problemas malvados" era cómo diseñar un programa de procesamiento de transacciones. En tal programa, un archivo secuencial de registros de actualización se ejecuta contra un archivo maestro secuencial, produciendo un archivo maestro actualizado como salida. (Por ejemplo, por la noche, un banco ejecutaría un programa por lotes que actualizaría los saldos en las cuentas de sus clientes en función de los registros de los depósitos y retiros que habían realizado ese día). Principios del diseño del programa proporcionó una solución estándar para ese problema, junto con una explicación de la lógica detrás del diseño.

Otro tipo de problema involucraba lo que Jackson llamó "dificultades de reconocimiento" y hoy llamaríamos problemas de análisis. La técnica básica de diseño de JSP se complementó con las operaciones POSIT y QUIT para permitir el diseño de lo que ahora llamaríamos un analizador de retroceso.

JSP también reconoció tres situaciones que se denominan "choques de estructuras" (un choque de límites, un choque de orden y un choque de intercalación) y proporcionó técnicas para tratarlas. En situaciones de conflicto de estructuras, las estructuras de datos de entrada y salida son tan incompatibles que no es posible generar el archivo de salida a partir del archivo de entrada. En efecto, es necesario escribir dos programas: el primero procesa el flujo de entrada, lo divide en fragmentos más pequeños y escribe esos fragmentos en un archivo intermedio. El segundo programa lee el archivo intermedio y produce la salida deseada.

JSP y diseño orientado a objetos

JSP se desarrolló mucho antes de que las tecnologías orientadas a objetos estuvieran disponibles. Ni él ni su método sucesor JSD tratan lo que ahora se llamaría "objetos" como colecciones de métodos más o menos independientes. En cambio, siguiendo el trabajo de C A R Hoare, JSP y JSD describen los objetos de software como co-rutinas.