Tecnologie di sviluppo software. Esistono solo paradigmi di programmazione strutturata e ad oggetti Descrivi l'approccio strutturato alla programmazione

Programmazioneè una branca della scienza e della tecnologia relativamente giovane e in rapido sviluppo. L'esperienza di condurre sviluppi reali e migliorare il software e l'hardware esistenti viene costantemente ripensata, a seguito della quale compaiono nuovi metodi, metodologie e tecnologie che, a loro volta, fungono da base per strumenti di sviluppo software più moderni. Si consiglia di studiare i processi di creazione di nuove tecnologie e determinarne le principali tendenze, confrontando queste tecnologie con il livello di sviluppo della programmazione e le caratteristiche degli strumenti software e hardware a disposizione dei programmatori.

Tecnologia di programmazione chiamare un insieme di metodi e strumenti utilizzati nel processo di sviluppo del software. Come qualsiasi altra tecnologia, una tecnologia di programmazione è un insieme di istruzioni tecnologiche, tra cui:

• un'indicazione della sequenza di esecuzione delle operazioni tecnologiche;
• enumerazione delle condizioni in cui questa o quell'operazione viene eseguita;
• descrizioni delle operazioni stesse, dove per ciascuna operazione sono determinati i dati iniziali, i risultati, nonché le istruzioni, le norme, gli standard, i criteri e le modalità di valutazione, ecc.

Oltre all'insieme delle operazioni e alla loro sequenza, la tecnologia determina anche il modo di descrivere il sistema progettato, più precisamente il modello utilizzato in una particolare fase di sviluppo.

Programmazione orientata agli oggetti (OOP)è definita come una tecnologia per la creazione di software complesso basata sulla rappresentazione di un programma come un insieme di oggetti, ognuno dei quali è un'istanza di un certo tipo (classe), e le classi formano una gerarchia con ereditarietà delle proprietà. L'interazione degli oggetti software in un tale sistema viene eseguita passando messaggi.

Il principale vantaggio della programmazione orientata agli oggetti rispetto alla programmazione modulare è la scomposizione del software "più naturale", che ne facilita notevolmente lo sviluppo. Questo porta ad una localizzazione più completa dei dati e alla loro integrazione con le routine di elaborazione, che consente lo sviluppo praticamente indipendente delle singole parti (oggetti) del programma. Inoltre, l'approccio a oggetti offre nuovi modi di organizzare i programmi basati sui meccanismi di ereditarietà, polimorfismo, composizione, riempimento. Questi meccanismi consentono di costruire oggetti complessi da quelli relativamente semplici. Il risultato è un aumento significativo del riutilizzo del codice e la capacità di creare librerie di classi per una varietà di usi.

Il rapido sviluppo delle tecnologie di programmazione basate sull'approccio a oggetti ha permesso di risolvere molti problemi. Pertanto, sono stati creati ambienti che supportano la programmazione visiva, ad esempio Delphi, C++ Builder, Visual C ++, ecc. Quando si utilizza l'ambiente visivo, il programmatore ha l'opportunità di progettare alcune parti, ad esempio le interfacce del prodotto futuro, utilizzando strumenti visivi per l'aggiunta e la configurazione di componenti di libreria speciali. Il risultato della progettazione visiva è la preparazione del programma futuro, in cui sono già stati inseriti i codici corrispondenti.

Puoi dare una definizione generale: Oggetto OOPè una raccolta di variabili di stato e metodi associati (operazioni). Questi metodi determinano come l'oggetto interagisce con il mondo esterno.

Sotto metodi oggetto comprendere procedure e funzioni, la cui dichiarazione è inclusa nella descrizione dell'oggetto e che eseguono azioni. La capacità di gestire gli stati di un oggetto chiamando i metodi alla fine determina il comportamento dell'oggetto. Questa raccolta di metodi viene spesso definita interfaccia dell'oggetto.

La programmazione strutturale (SP) è emersa come soluzione al problema di ridurre la DIFFICOLTÀ dello sviluppo del software.

All'inizio dell'era della programmazione, il lavoro di un programmatore non era regolato da nulla. I compiti da risolvere non differivano per portata e scala, sono stati utilizzati principalmente linguaggi orientati alla macchina e linguaggi simili come Assembler, i programmi sviluppati raramente hanno raggiunto dimensioni significative e non sono state imposte rigide restrizioni sul tempo della loro sviluppo.

Con lo sviluppo della programmazione sono comparsi problemi, per la cui soluzione sono stati determinati tempi limitati di problemi sempre più complessi con il coinvolgimento di gruppi di programmatori. Di conseguenza, gli sviluppatori hanno dovuto affrontare il fatto che i metodi adatti allo sviluppo di piccoli problemi non possono essere utilizzati nello sviluppo di grandi progetti a causa della complessità di questi ultimi.

Pertanto, lo scopo della programmazione strutturata è migliorare l'affidabilità dei programmi, fornire manutenzione e modifica, facilitazione e accelerazione dello sviluppo.

Metodologia di programmazione imperativa strutturata - un approccio consistente nell'impostare una buona topologia di programmi imperativi, incluso il rifiuto di utilizzare dati globali e l'operatore di salto incondizionato, sviluppando moduli con forte connettività e garantendo la loro indipendenza da altri moduli.

L'approccio si basa su due principi fondamentali:

· Scomposizione sequenziale dell'algoritmo per la risoluzione del problema dall'alto verso il basso.

· Utilizzo di codifica strutturata.

Ricordiamo che questa metodologia è lo sviluppo più importante della metodologia imperativa.

Origine, storia ed evoluzione. Edsger Dijkstra è considerato il creatore dell'approccio strutturato. Fece anche un tentativo (purtroppo del tutto inapplicabile per la programmazione di massa) di combinare la programmazione strutturata con metodi per dimostrare la correttezza dei programmi creati. Scienziati famosi come H. Mills, D.E. Knuth, S. Hoor.

Metodi e concetti alla base della programmazione strutturata. Ce ne sono tre

Metodo decomposizione algoritmica top-down- consiste nel dettaglio passo passo dell'affermazione del problema, partendo dal problema più generale. Questo metodo fornisce una buona struttura. Il metodo è supportato dal concetto di algoritmo.

Metodo organizzazione modulare delle parti di programma- consiste nello scomporre il programma in componenti speciali chiamati moduli. Il metodo è supportato dal concetto di modulo.

Metodo codifica strutturale- consiste nell'utilizzare tre principali costrutti di controllo durante la codifica. Le etichette e l'operatore di salto incondizionato sono relazioni difficili da tracciare di cui vogliamo fare a meno. Il metodo è supportato dal concetto di controllo

Linguaggi di programmazione strutturale. La principale differenza rispetto alla metodologia classica della programmazione imperativa è il fallimento (più precisamente, l'uno o l'altro grado di fallimento) dall'operatore di salto incondizionato .

"Una proprietà importante della sintassi per il programmatore è la capacità riflettere nella struttura del programma la struttura dell'algoritmo sottostante. Quando si utilizza il metodo noto come programmazione strutturata, il programma è costruito gerarchicamente - dall'alto verso il basso (dal programma principale alle subroutine del livello più basso), con l'uso di un insieme limitato di strutture di controllo ad ogni livello: semplici sequenze di istruzioni, loop e alcuni tipi di ramificazione condizionale. Con un'implementazione coerente di questo metodo, la struttura degli algoritmi risultanti è facile da comprendere, eseguire il debug e modificare. Idealmente, dovremmo essere in grado di tradurre lo schema del programma costruito in questo modo direttamente nelle istruzioni del programma corrispondenti che riflettono la struttura dell'algoritmo".

Teorema di strutturazione (Boem-Jacopini): Qualsiasi programma corretto (cioè un programma con un ingresso e un'uscita senza loop e rami irraggiungibili) può essere scritto utilizzando le seguenti strutture logiche - sequenza, selezione e ripetizione del loop

Corollario 1: Qualsiasi programma può essere ridotto a un modulo senza un'istruzione goto.

Corollario 2: Qualsiasi algoritmo può essere implementato in un linguaggio basato su tre costrutti di controllo: sequenza, ciclo, ripetizione.

Corollario 3: La complessità dei programmi strutturati è limitata, anche se di dimensioni illimitate.

La programmazione strutturata non è fine a se stessa. Il suo scopo principale è ottenere un buon programma ("corretto"), tuttavia, anche nel miglior programma, a volte sono necessarie istruzioni goto: ad esempio, per uscire da una serie di cicli annidati.

In quasi tutte le lingue che supportano la metodologia imperativa, è possibile sviluppare programmi secondo questa metodologia. Numerosi linguaggi hanno introdotto sostituti speciali per l'istruzione goto per semplificare la gestione dei loop (ad esempio, Break e Continue in C).

Classe di compiti. La classe dei problemi per una data metodologia corrisponde alla classe dei problemi per una metodologia imperativa. Si noti che ciò consente di sviluppare programmi più complessi, poiché sono facili da percepire e analizzare.

Programmazione strutturaleno è la prima metodologia di programmazione completa. La programmazione strutturata ha avuto un enorme impatto sullo sviluppo della programmazione. Questo metodo è stato ampiamente utilizzato nella programmazione pratica e fino ad oggi non ha perso il suo significato per una certa classe di problemi.

L'approccio strutturato si basa su due principi fondamentali:

1 è l'uso di linguaggi di programmazione procedurale (Algol, Pascal, SI);

2 è una scomposizione sequenziale top-down dell'algoritmo per la risoluzione del problema.

Il problema viene risolto applicando una sequenza di azioni. Inizialmente, il compito è formulato in termini di input-output. Ciò significa che alcuni dati vengono forniti all'input del programma. Il programma funziona e dà una risposta.

Successivamente, inizia la scomposizione sequenziale dell'intera attività in azioni più semplici.

Ad esempio, se dobbiamo scrivere un programma per verificare la correttezza dell'indirizzo, prima lo scriveremo come segue:

Controllare l'indirizzo rispetto al database degli indirizzi disponibili

Se il test è positivo,stampa Sì,

altrimenti, stampa n.

Ovviamente, una tale notazione uno a uno viene visualizzata in un programma in un linguaggio di alto livello, ad esempio in Pascal.

programma check_address (input, output); varan_address: indirizzo; iniziare read_address (un _address);

if (check_database (an_address)) then

writelnTMIa "); else

Questo programma utilizza la procedura leggere_ indirizzo per leggere l'indirizzo e la procedura dai un'occhiata_ Banca dati per controllare l'indirizzo letto con le informazioni nel database. Ora possiamo continuare il processo di compilazione di un programma per le procedure di livello successivo: lettura dell'indirizzo e verifica nel database.

È molto importante che il programma possa essere controllato in qualsiasi momento. Per fare ciò, è necessario scrivere stub, procedure che simulano l'ingresso e l'uscita di procedure di livello inferiore. (Nel programma sopra, puoi usare la procedura di lettura dell'indirizzo, che sostituisce semplicemente un indirizzo fisso invece dell'input dal terminale, e la procedura di controllo del database, che non fa nulla, ma semplicemente restituisce sempre true.)

Il programma si collega agli stub e può funzionare. Gli stub ti consentono di testare la tua logica di primo livello prima di implementare il livello successivo.

La programmazione strutturata è chiaramente definita il valore della programmazione modulare quando si sviluppano progetti di grandi dimensioni, ma i linguaggi di programmazione sono ancora scarsamente supportati dalla modularità. L'unico modo per strutturare i programmi era comporli da sottoprogrammi o funzioni. Il controllo sulla correttezza delle chiamate di funzione, inclusa la corrispondenza del numero e dei tipi di argomenti effettivi ai parametri formali previsti, è stato effettuato solo nella fase di esecuzione (il concetto di prototipo di funzione è apparso in seguito).

1.4. Fondamenti e storia della programmazione orientata agli oggetti

La programmazione orientata agli oggetti è emersa e si è diffusa grazie alla realizzazione di tre principali problemi di programmazione.

1 - lo sviluppo di linguaggi e metodi di programmazione non ha tenuto il passo con le crescenti esigenze di programmi. L'unico vero modo per soddisfare queste esigenze era riutilizzare il software già sviluppato, testato e sottoposto a debug.

2 - la necessità di semplificare la manutenzione e la modifica dei sistemi sviluppati. (Il fatto di cambiamenti costanti nei requisiti per il sistema è stato riconosciuto come una condizione normale per lo sviluppo del sistema, e non come un'incapacità o un'organizzazione non sufficientemente chiara del lavoro degli sviluppatori.) Era necessario cambiare il modo di costruire sistemi software in modo che le modifiche locali non interrompano le prestazioni dell'intero sistema e sia più facile apportare modifiche al comportamento del sistema ...

3 è quello di facilitare la progettazione del sistema. Non tutti i problemi si prestano alla descrizione algoritmica e, inoltre, alla scomposizione algoritmica, come richiesto dalla programmazione strutturata. Era necessario avvicinare la struttura del programma alla struttura dei compiti da risolvere e ridurre il cosiddetto rottura semantica tra la struttura del problema da risolvere e la struttura del programma. Un gap semantico si verifica quando i concetti alla base del linguaggio del problema e i mezzi per risolverlo sono diversi. Pertanto, oltre alla necessità di registrare la soluzione stessa, è anche necessario tradurre alcuni concetti in altri. (Confronta questo con la traduzione da una lingua naturale in un'altra. Proprio perché prima non esistevano tali concetti nella lingua russa, parole come broker, offshore o investitore. Sfortunatamente, nella programmazione, non è possibile prendere in prestito le parole.)

Quindi, semplificare la progettazione, accelerare lo sviluppo attraverso il riutilizzo di moduli già pronti e la facilità di modifica: questi sono i tre principali vantaggi della programmazione orientata agli oggetti, promossi dai suoi sostenitori.

La programmazione orientata agli oggetti presuppone un approccio unificato alla progettazione, costruzione e sviluppo di un sistema.

L'emergere del metodo orientato agli oggetti si è verificato sulla base di tutto il precedente sviluppo dei metodi di sviluppo del software, così come di molti altri rami della scienza.

L'emergere di un approccio orientato agli oggetti alla progettazione del sistema è stato facilitato dai seguenti progressi tecnologici:

1 - Lo sviluppo della tecnologia informatica, in particolare, il supporto hardware per i concetti di base dei sistemi operativi e la costruzione di sistemi orientati alle funzioni.

2 - Progressi nella metodologia di programmazione, in particolare nella costruzione di sistemi modulari e nell'incapsulamento delle informazioni.

3 - La teoria della costruzione e modellazione dei sistemi di gestione di database ha introdotto l'idea di costruire relazioni tra oggetti nella programmazione degli oggetti.

4 - La ricerca sull'intelligenza artificiale ha portato a una migliore comprensione dei meccanismi di astrazione. La teoria dei frame proposta da Minsky per rappresentare oggetti reali nei sistemi di riconoscimento delle immagini ha dato un potente impulso non solo ai sistemi di intelligenza artificiale, ma anche ai meccanismi di astrazione nei linguaggi di programmazione.

5 - Sviluppo della filosofia e teoria della conoscenza. In molti modi, la costruzione di sistemi orientati agli oggetti è una certa visione del mondo reale simulato. È in questo aspetto che la filosofia e la teoria della conoscenza hanno avuto una forte influenza sul modello a oggetti. Anche gli antichi greci consideravano il mondo sotto forma di oggetti o processi. Cartesio ha avanzato l'ipotesi che una considerazione orientata agli oggetti del mondo circostante sembra naturale per una persona. Minsky ha suggerito che la ragione si manifesta come l'interazione di agenti che non possono pensare separatamente.

La programmazione orientata agli oggetti è supportata da linguaggi di programmazione come Smalltalk, C++, Java, ecc. I linguaggi sono gli strumenti principali per la programmazione orientata agli oggetti, è stato durante il loro sviluppo che è apparsa la maggior parte delle idee che costituiscono la base del metodo orientato agli oggetti.

Il primo passo verso la creazione di un modello a oggetti dovrebbe essere considerato l'emergere di tipi di dati astratti. Si ritiene che la prima implementazione completa di tipi di dati astratti nei linguaggi di programmazione sia il linguaggio Simula.

Poi sono arrivati ​​(e continuano ad emergere) altri linguaggi orientati agli oggetti che definiscono lo stato dell'arte della programmazione. I più comuni sono C++, CLOS, Eiffel, Java.

Template: software basato sulla presentazione del programma sotto forma di una struttura gerarchica a blocchi. Proposto negli anni '70 del XX secolo da E. Dijkstroy, sviluppato e integrato da N. Virt.

Secondo questa metodologia

1. Qualsiasi programma è una struttura costituita da tre tipi di strutture di base:
   • esecuzione sequenziale- un'unica esecuzione delle operazioni nell'ordine in cui sono scritte nel testo del programma;
   • ramificazione- esecuzione una tantum di una di due o più operazioni, a seconda del soddisfacimento di una determinata condizione;
   • ciclo- esecuzione multipla della stessa operazione purché sia ​​soddisfatta una data condizione (condizione per la prosecuzione del ciclo).
   In un programma, i costrutti di base possono essere annidati l'uno nell'altro in modo arbitrario, ma non sono forniti altri mezzi per controllare la sequenza delle operazioni.
2. Frammenti di programma ripetuti (o non ripetuti, ma che rappresentano blocchi computazionali logicamente integrali) possono essere formati nella forma del cosiddetto. subroutine (procedure o funzioni). In questo caso, nel testo del programma principale, al posto del frammento posto nel sottoprogramma, viene inserita l'istruzione chiamata di sottoprogramma... Quando viene eseguita tale istruzione, viene eseguita la subroutine richiamata, dopodiché l'esecuzione del programma prosegue con l'istruzione successiva al comando di chiamata della subroutine.
3. Lo sviluppo del programma avviene passo dopo passo, con il metodo "top down".

Innanzitutto viene scritto il testo del programma principale, nel quale, al posto di ogni frammento logico coerente di testo, viene inserita una chiamata a una subroutine che eseguirà questo frammento. Invece di vere e proprie subroutine funzionanti, nel programma vengono inseriti degli "stub", che non fanno nulla. Il programma risultante viene controllato e sottoposto a debug. Dopo che il programmatore si è assicurato che i sottoprogrammi vengano richiamati nella sequenza corretta (cioè che la struttura generale del programma sia corretta), gli stub vengono sostituiti in sequenza con quelli effettivamente funzionanti e lo sviluppo di ogni sottoprogramma viene eseguito nella allo stesso modo del programma principale. Lo sviluppo termina quando non rimane un solo "tappo" che non sarebbe stato rimosso. Questa sequenza assicura che in ogni fase dello sviluppo, il programmatore si occupi simultaneamente di una moltitudine di frammenti che sono visibili e comprensibili per lui e può essere sicuro che la struttura generale di tutti i livelli superiori del programma sia corretta. Quando si effettua la manutenzione e si apportano modifiche al programma, diventa chiaro quali procedure devono essere modificate e vengono eseguite senza influire sulle parti del programma che non sono direttamente correlate ad esse. Ciò consente di garantire che quando si apportano modifiche e si correggono errori, alcune parti del programma che sono attualmente al di fuori dell'attenzione del programmatore non si interrompano.

Teorema della programmazione strutturata:

Articolo principale: Teorema di Bohm-Jacopini

Qualsiasi schema dell'algoritmo può essere rappresentato come una composizione di blocchi di inizio e fine annidati, istruzioni condizionali if, then, else, cicli con una precondizione (while) e possono essere presenti variabili logiche aggiuntive (flag).
Questo teorema è stato formulato dai matematici italiani C. Bohm e J. Jacopini nel 1966 e ci dice come evitare di usare l'operatore goto.

Storia

La metodologia di programmazione strutturata è apparsa come conseguenza della crescente complessità dei compiti risolti sui computer e della corrispondente complicazione del software. Negli anni '70, il volume e la complessità dei programmi raggiunsero un livello tale che lo sviluppo "intuitivo" (non strutturato o "riflesso") dei programmi, che era la norma in passato, cessò di soddisfare le esigenze della pratica. I programmi sono diventati troppo complessi per essere mantenuti correttamente, quindi è stata necessaria una sorta di sistematizzazione del processo di sviluppo e della struttura dei programmi.

La critica più forte da parte degli sviluppatori dell'approccio strutturato alla programmazione è stata l'operatore GOTO (operatore di salto incondizionato), che era quindi disponibile in quasi tutti i linguaggi di programmazione. L'uso scorretto e sconsiderato di transizioni arbitrarie nel testo del programma porta a programmi confusi e mal strutturati (il cosiddetto codice spaghetti), dal cui testo è quasi impossibile comprendere l'ordine di esecuzione e l'interdipendenza dei frammenti.

Seguendo i principi della programmazione strutturata, i testi dei programmi, anche piuttosto grandi, erano normalmente leggibili. La comprensione dei programmi è diventata molto più semplice, è diventato possibile sviluppare programmi in una normale modalità industriale, quando il programma può essere facilmente compreso non solo dal suo autore, ma anche da altri programmatori. Ciò ha permesso di sviluppare sistemi software sufficientemente grandi per quel tempo grazie agli sforzi dei team di sviluppo e di accompagnare questi complessi per molti anni, anche a fronte di inevitabili cambiamenti nel personale.

La metodologia di sviluppo del software strutturato è stata riconosciuta come "la più forte formalizzazione degli anni '70". Da allora, la parola "strutturale" è diventata di moda nel settore e ha iniziato a essere utilizzata ovunque sia necessario e dove non è necessario. Ci sono stati lavori su "progetto strutturale", "collaudo strutturale", "progetto strutturale" e così via. In generale, è successa la stessa cosa che è successa negli anni '90 e sta accadendo ora con i termini "oggetto", "orientato all'oggetto" ed "elettronico".

Ecco alcuni dei vantaggi della programmazione strutturata:

1. La programmazione strutturata consente di ridurre significativamente il numero di opzioni per la creazione di un programma secondo la stessa specifica, il che riduce significativamente la complessità del programma e, soprattutto, rende più facile la comprensione per gli altri sviluppatori.
2. Nei programmi strutturati, gli operatori logicamente connessi sono visivamente più vicini e quelli debolmente connessi sono più lontani, il che rende possibile fare a meno dei diagrammi a blocchi e di altre forme grafiche di visualizzazione degli algoritmi (in effetti, il programma stesso è il proprio diagramma a blocchi).
3. Il processo di test e debug di programmi strutturati è notevolmente semplificato.

Guarda anche

Link

Fondazione Wikimedia. 2010.

• Mahajanapada
• Cammello

Guarda cos'è la "Programmazione strutturata" in altri dizionari:

Programmazione strutturata- metodologia e tecnologia per lo sviluppo di sistemi software basati sui principi di: programmazione top-down; programmazione modulare. In questo caso, la logica dell'algoritmo e dei programmi deve utilizzare tre strutture principali: sequenziale ... ... Vocabolario finanziario

programmazione strutturata- struktūrinis programavimas statusas T sritis automatika atitikmenys: angl. codifica strutturata; programmazione strutturata vok. strukturelle Programmierung, fr. programmazione strutturata, n; programmazione strutturata, n pranc.…… Automatikos terminų žodynas

Programmazione strutturata- 46. Programmazione strutturata Programmazione strutturata Fonte: GOST 19781 90: Software per sistemi di elaborazione delle informazioni. Termini e definizioni … Dizionario-libretto di riferimento dei termini della documentazione normativa e tecnica

Programmazione- Questo articolo deve essere completamente riscritto. Potrebbero esserci delle spiegazioni nella pagina di discussione. Questo termine ha altri significati, vedi Programmi... Wikipedia

PROGRAMMAZIONE- 1) il processo di elaborazione di un programma, un piano d'azione. 2) Sezione di informatica, studio dei metodi e delle tecniche di programmazione. Con un po' di convenzione, il P. come disciplina si divide in: teorico, mat da studio. astrazioni di programmi (come oggetti con ... ... Enciclopedia fisica

Programmazione basata su prototipi- La programmazione prototipo è uno stile di programmazione orientata agli oggetti in cui non esiste il concetto di classe e il riutilizzo (ereditarietà) viene effettuato clonando un'istanza esistente di un oggetto prototipo. ... ... Wikipedia

Paradigma (programmazione)- Il paradigma di programmazione è una raccolta di idee e concetti che determina lo stile di scrittura dei programmi. Il paradigma è determinato principalmente dall'unità di programma di base e dal principio stesso di raggiungere la modularità del programma. Poiché questa unità ... Wikipedia

Programmazione computer- Analisi delle fasi del processo del processo di sviluppo del software | Progettazione | Attuazione | Test | Attuazione | Mantenimento di modelli/metodi agili | Camera bianca | Iterativo | Mischia | RUP | MSF | Spirale | ... Wikipedia

Programmazione non strutturata- Metodologia di sviluppo del software di programmazione strutturata, che si basa sulla presentazione del programma sotto forma di una struttura gerarchica a blocchi. Proposto negli anni '70 del XX secolo da E. Dijkstroy, sviluppato e integrato da N. Virt. In ... Wikipedia

Programmazione orientata ai componenti- Paradigmi di programmazione Agent-oriented Component-oriented Concatenative Dichiarativo (in contrasto con l'imperativo) Vincoli Funzionali Flusso di dati Orientato alla tabella (fogli di calcolo) Reattivo ... Wikipedia

libri

• La disciplina della programmazione, Dijkstra E. Il libro è stato scritto da uno dei più grandi esperti stranieri nel campo della programmazione, noto al lettore sovietico per aver tradotto i suoi libri in russo (ad esempio, "Structural ...

La programmazione strutturata rappresenta il più grande progresso in questo settore fino ad oggi. Nonostante quasi tutti abbiano un concetto generale al riguardo, quasi nessuno può dare una definizione specifica e chiara di questo termine. La programmazione strutturata si pone l'obiettivo principale di scrivere programmi della minima complessità, costringendo il programmatore a pensare in modo chiaro, rendendo il programma più facile da capire. Il suo testo deve essere fatto in modo che sia leggibile dall'alto verso il basso. Questa condizione viene violata se si incontrano istruzioni go to nel codice del programma, poiché violano la struttura dell'intero segmento di programma. Nonostante questo indicatore non possa essere considerato il più conveniente, si può comunque affermare che la presenza di questo operatore nel codice del programma è il tipo più evidente di violazione della struttura. I corpi dei moduli e le strutture sottostanti utilizzate devono essere resistenti a guasti hardware, errori nei programmi e distorsioni dei dati originali.

I principi di base della programmazione strutturata sono i seguenti. Qualsiasi programma può essere facilmente sintetizzato sulla base di costruzioni elementari di tre tipi principali:

Consistenza semplice;

Condizioni o alternative;

Ripetizioni, cioè loop e iterazioni.

Uno o due di qualsiasi tipo possono essere usati contemporaneamente. Ogni struttura ha una singola caratteristica: un unico punto di trasferimento del controllo alla struttura e l'unico punto di ingresso nella struttura. Questo tipo di costruzione ha un significato disciplinante e sistematizzante.

La semplicità dei costrutti iniziali nella programmazione strutturata impedisce connessioni informative e trasferimenti di controllo confusi. La complessità dei programmi si riduce notevolmente con un aumento della struttura dei moduli, la loro chiarezza aumenta e questo aiuta a ridurre il numero di errori. Tuttavia, la strutturazione ha anche uno svantaggio: per la bellezza e la chiarezza del codice del programma devi pagare con memoria aggiuntiva, nonché il tempo necessario per la loro implementazione su un computer.

La programmazione strutturale, ovvero la struttura dei testi stessi del programma, dipende interamente dal linguaggio utilizzato per questo. Naturalmente, sorge la domanda, quale è più adatto. I moderni strumenti di sviluppo software sono considerati i migliori linguaggi per implementare un approccio strutturato alla programmazione. Tra i più comuni ci sono Basic, Pascal e FoxBASE. Ad esempio, è praticamente impossibile attuare i principi enunciati nel concetto di programmazione strutturata. Questo linguaggio è focalizzato sulla scrittura di codice di programmazione di basso livello.

La programmazione strutturata è fondamentalmente focalizzata sulla comunicazione con le persone, non con le macchine, quindi facilita la scrittura di programmi che rappresentano una soluzione chiara e semplice a un determinato problema. Il programmatore deve pensare in termini di costrutti strutturali di base.

Se parliamo della posizione relativa al sopracitato vai all'operatore, allora dovrebbe essere evitato ove possibile, ma ciò non dovrebbe in alcun modo pregiudicare la chiarezza del programma. A volte l'uso di questo operatore risulta essere semplicemente necessario per uscire da un determinato segmento di un programma o ciclo, nonché per evitare la comparsa di fork troppo profondi, soprattutto perché la transizione è associata a livelli inferiori di programmi. Allo stesso tempo, la struttura del programma rimane facilmente leggibile dall'alto verso il basso. Il peggio dell'operatore dato ha a che fare con l'andare dal basso verso l'alto.

Per facilitare la lettura, i programmi spesso aggiungono righe vuote tra le sezioni. Vale la pena scrivere il testo del programma con i turni in modo da poter leggere la sequenza delle azioni e il numero di allegati.

Software

L'approccio strutturale alla programmazione è sia una metodologia che una tecnologia per la creazione di programmi. Un tempo, la sua implementazione forniva un aumento della produttività dei programmatori durante la scrittura e il debug dei programmi; ottenere programmi composti da moduli e adatti alla manutenzione; creazione di programmi da parte di un team di sviluppatori; la fine della creazione del programma in un determinato momento.

La programmazione strutturata è un approccio che utilizza costrutti per trasferire il controllo in un programma che consente trasferimenti di controllo sequenziali, condizionali e iterativi. È vietato il trasferimento incondizionato del controllo tramite l'istruzione goto. Di conseguenza, ogni comando complesso nel programma, che è una combinazione di istruzioni sequenziali, condizionali e cicliche, ha un solo punto di ingresso e di uscita, il che garantisce che il programma sia suddiviso in frammenti relativamente indipendenti.

La programmazione strutturata è il risultato dell'applicazione di tecniche applicative a programmi imperativi. Per questo vengono utilizzati linguaggi orientati alla procedura, in cui è possibile descrivere un programma come un insieme di procedure. Le procedure possono chiamarsi a vicenda e ognuna di esse può essere chiamata dal programma principale, che può anche essere pensato come una procedura.

La struttura del programma sono le parti interagenti del programma allocate artificialmente dal programmatore. L'uso di una struttura razionale elimina il problema della complessità dello sviluppo, rende il programma comprensibile agli utenti, aumenta l'affidabilità del programma riducendo il periodo di test e tempo di sviluppo.

Molto spesso, una determinata sequenza di istruzioni deve essere ripetuta in punti diversi del programma. In modo che il programmatore non debba dedicare tempo e fatica a copiare queste istruzioni, molti linguaggi di programmazione forniscono strumenti per l'organizzazione delle subroutine. Il programmatore ha l'opportunità di assegnare un nome arbitrario alla sequenza di istruzioni e utilizzare questo nome come abbreviazione nei punti in cui si verifica la sequenza di istruzioni corrispondente. Quindi, una subroutine è una sequenza di istruzioni che può essere chiamata in più punti di un programma. Le subroutine sono generalmente chiamate procedure e funzioni.

La descrizione di una subroutine è composta da due parti: intestazioni e corpi. L'intestazione contiene l'identificatore della subroutine e le variabili utilizzate in essa. Il corpo è costituito da una o più istruzioni. L'identificatore di subroutine viene utilizzato come notazione abbreviata in quei punti del programma in cui si verifica la sequenza di istruzioni corrispondente.

Procedure e funzioni, dette subroutine, sono uno dei pochi strumenti fondamentali nell'arte della programmazione che hanno un'influenza decisiva sullo stile e sulla qualità del lavoro di un programmatore.

Una procedura non è solo un modo per abbreviare il testo di un programma, ma anche un mezzo per scomporre un programma in elementi chiusi logicamente collegati che ne definiscono la struttura. Scomporre un programma in parti è essenziale per comprendere il programma, soprattutto se il programma è complesso e difficile da vedere a causa della grande lunghezza del testo. La scomposizione in sottoprogrammi è necessaria sia per documentare che per verificare il programma. Pertanto, è desiderabile formulare una sequenza di istruzioni sotto forma di sottoprogramma, anche se il programma viene utilizzato una sola volta e, quindi, non vi è alcun motivo associato alla riduzione del testo del programma.

Le informazioni sulle variabili o le condizioni che gli argomenti devono soddisfare sono specificate nell'intestazione della procedura. L'utilità della procedura, in particolare, il suo ruolo nella strutturazione di un programma, è indiscutibilmente evidenziata da altri due concetti di programmazione. La convenienza o le variabili locali utilizzate all'interno di una procedura non hanno alcun significato al di fuori di essa. È più facile comprendere una creatura in un programma se gli ambiti di tali variabili sono specificati in modo esplicito. La procedura agisce come un'unità di testo naturale, con l'aiuto della quale l'ambito di esistenza delle variabili locali è limitato.

La tattica di programmazione più comune è quella di scomporre un processo in singole azioni:

• - descrizione funzionale per sottofunzioni;
• - programmi appropriati per istruzioni separate.

In ciascuna di queste fasi della scomposizione, è necessario assicurarsi che le soluzioni di problemi particolari portino alla soluzione del problema generale, la sequenza selezionata di singole azioni sia ragionevole e consenta di ottenere istruzioni in un certo senso più vicine a la lingua in cui verrà implementato il programma. Questo requisito esclude la possibilità di un semplice avanzamento dall'impostazione iniziale del problema al programma finale, che alla fine dovrebbe essere ottenuto. Ogni fase della scomposizione è accompagnata dalla formulazione di sottoprogrammi privati. Nel corso di questo lavoro, potresti scoprire che la scomposizione scelta non ha successo, nel senso che è scomodo esprimere sottoprogrammi usando i mezzi disponibili. In questo caso, uno o più dei precedenti passaggi di decomposizione dovrebbero essere rivisti.

Se vediamo progressi graduali in profondità nella scomposizione passo-passo e nello sviluppo e nel dettaglio simultanei del programma, allora un tale metodo nella risoluzione dei problemi può essere caratterizzato come dall'alto verso il basso (dall'alto verso il basso). E viceversa, un tale approccio alla risoluzione del problema è possibile, quando il programmatore prima studia il computer o il linguaggio di programmazione a sua disposizione, quindi raccoglie alcune sequenze di istruzioni in procedure elementari tipiche del problema da risolvere. Le procedure elementari vengono quindi utilizzate al livello successivo della gerarchia delle procedure. Questo metodo per passare dalle istruzioni macchina primitive all'implementazione del programma richiesta è chiamato bottom-up (bottom-up).

In pratica, lo sviluppo di un programma non può mai essere eseguito rigorosamente in una direzione: dall'alto verso il basso o dal basso verso l'alto. Tuttavia, quando si progettano nuovi algoritmi, di solito prevale l'approccio top-down. D'altra parte, quando si adatta un programma a requisiti leggermente modificati, spesso si preferisce l'approccio dal basso verso l'alto.

Entrambi i metodi consentono di sviluppare programmi che hanno struttura, una proprietà che li distingue dalle sequenze lineari amorfe di istruzioni o istruzioni macchina. È importante che il linguaggio utilizzato rifletta pienamente questa struttura. Solo allora la forma definitiva del programma risultante consentirà l'applicazione di metodi di verifica sistematica.

Se un programma è suddiviso in sottoprogrammi, è spesso necessario introdurre nuove variabili per rappresentare i risultati e gli argomenti, e quindi stabilire collegamenti tra i sottoprogrammi. Tali variabili dovrebbero essere introdotte e descritte nella fase di sviluppo in cui sono richieste. Inoltre, la descrizione dettagliata del processo può essere accompagnata dalla descrizione dettagliata della struttura delle variabili utilizzate. Pertanto, il linguaggio deve avere un mezzo per riflettere la struttura gerarchica dei dati. Ciò mostra quale ruolo importante giocano il concetto di procedura, località di procedure e dati e strutturazione dei dati nello sviluppo passo dopo passo di un programma.

La progettazione inizia con la fissazione delle specifiche esterne. Sulla base delle specifiche esterne, viene redatta una descrizione dell'algoritmo interno del programma, necessariamente con la struttura dei dati interni. Inoltre, le funzioni di grandi dimensioni sono suddivise in sottofunzioni fino a quando non viene raggiunta la sottofunzione della dimensione del modulo: le subroutine del linguaggio di programmazione, alle quali vengono imposti requisiti aggiuntivi speciali.

Il concetto fondamentale e l'elemento funzionale della tecnologia di programmazione strutturata è un modulo.

Un modulo è una subroutine, ma formattata secondo le seguenti regole:

• 1. il modulo deve avere un ingresso e un'uscita e svolgere una funzione rigorosamente univoca, che è descritta da una semplice frase comune della lingua naturale (russa) o anche una frase senza predicato;
• 2. il modulo deve prevedere la compilazione, indipendente da altri moduli, con "dimenticanza" di tutti i valori interni dei moduli;
• 3. un modulo può chiamare altri moduli con i loro nomi;
• 4. un buon modulo non utilizza variabili globali per comunicare con un altro modulo, poiché allora è difficile trovare un modulo che corrompe i dati. Quando si utilizzano variabili globali, è necessario commentare chiaramente quei moduli che leggono solo e quei moduli che possono modificare i dati;
• 5. Il modulo è codificato solo con strutture standard ed è ampiamente commentato.

Il concetto di struttura del programma comprende la composizione e la descrizione delle connessioni di tutti i moduli che implementano le funzioni autonome del programma e la descrizione dei supporti dati che partecipano allo scambio, sia tra i singoli sottoprogrammi che in ingresso e in uscita da dispositivi esterni.

Nel caso di un programma complesso e di grandi dimensioni, è necessario padroneggiare tecniche speciali per ottenere una struttura razionale del programma. La struttura razionale del programma fornisce una riduzione quasi doppia della quantità di programmazione e una riduzione molteplice dell'ambito e del tempo di test, quindi riduce sostanzialmente i costi di sviluppo.

È conveniente rappresentare la subordinazione dei moduli mediante un diagramma gerarchico. Il diagramma della gerarchia riflette solo la subordinazione delle subroutine, ma non l'ordine della loro invocazione o il funzionamento del programma.

Prima di elaborare un diagramma della gerarchia, è consigliabile redigere specifiche esterne del programma e redigere descrizioni funzionali del programma insieme alla descrizione delle variabili - supporti dati. Particolare attenzione dovrebbe essere prestata alla gerarchia dei tipi di dati strutturati e ai loro commenti. La scomposizione di un programma in sottoprogrammi avviene secondo il principio dal generale al particolare, più dettagliato. Il processo di costruzione di una descrizione funzionale e di mappatura di una gerarchia è iterativo. La scelta dell'opzione migliore è multicriterio.

• - modularità dei programmi;
• - codifica strutturale dei moduli del programma;
• - progettazione top-down di una gerarchia razionale dei moduli del programma;
• - implementazione top-down del programma tramite stub;
• - attuazione della pianificazione in tutte le fasi del progetto;
• - controllo strutturale end-to-end dei sistemi software nel loro insieme e dei loro moduli costitutivi.

La modularità dei programmi è caratterizzata dal fatto che l'intero programma è costituito da moduli. Alcuni gruppi semantici di moduli sono concentrati in file separati. Ad esempio, i moduli dell'editor di testo ei moduli del menu gerarchico possono essere concentrati in file separati (Unità).

La codifica strutturale dei moduli del programma consiste nella progettazione speciale dei loro testi. Il modulo dovrebbe avere un'intestazione facilmente riconoscibile con un commento che ne spieghi la funzionalità. I nomi delle variabili devono essere mnemonici. L'essenza delle variabili e l'ordine di immissione delle informazioni in esse dovrebbero essere spiegati dai commenti, il codice del modulo è codificato utilizzando strutture algoritmiche standard utilizzando i rientri.

La progettazione top-down di una gerarchia razionale di moduli di programma consiste nell'isolare i moduli originali del livello più alto della gerarchia e quindi i moduli subordinati.

L'implementazione top-down del programma consiste nell'implementazione iniziale di un gruppo di moduli dei livelli superiori, che sono chiamati il ​​nucleo del programma, e quindi gradualmente, secondo il piano, vengono implementati i moduli dei livelli inferiori . I programmi necessari per il collegamento, i moduli mancanti sono imitati da stub.

L'implementazione della pianificazione in tutte le fasi del progetto consente di pianificare inizialmente sia la composizione delle fasi che la durata di tutte le fasi del lavoro. Questa pianificazione consente di completare lo sviluppo in tempo a un determinato costo di sviluppo.

Il controllo strutturale end-to-end consiste nell'adesione a un piano di test predeterminato, che copre il periodo che va dallo sviluppo delle specifiche esterne, quindi alle specifiche interne e alla loro correzione durante il periodo di attuazione fino ai test di accettazione. I moduli che compongono il programma vengono testati sia al momento della scrittura del loro codice, sia durante i test offline, ispezione del loro codice sorgente, durante i test subito dopo la connessione al kernel.

Nella programmazione strutturata, il programma è generalmente implementato (costruito e testato) dall'alto verso il basso. Innanzitutto, un kernel viene scritto da 20-30 moduli. Per iniziare il test, i moduli di livello inferiore mancanti vengono sostituiti con stub. Al termine del test del kernel, gli stub vengono sostituiti con nuovi moduli già pronti, ma se il programma non è ancora terminato, saranno necessari tutti i nuovi stub dei moduli mancanti per il corretto collegamento. Quindi la parte assemblata viene testata, ecc.

Uno stub è un modulo fittizio. Lo stub più semplice è un programma o una funzione senza azione. Uno stub più complesso può visualizzare un messaggio che afferma che tale modulo ha funzionato. Stub ancora più complessi possono inviare l'input a un file di debug. Infine, stub ancora più complessi generano le informazioni di test necessarie per testare i moduli già implementati. Scrivere stub è un lavoro ridondante, ma ci vuole l'abilità del progettista per mantenere il maggior numero possibile di stub il più semplice possibile e per completare il test della parte preassemblata del programma.

La progettazione della struttura del programma è preceduta dallo sviluppo di descrizioni funzionali esterne. Le descrizioni funzionali (algoritmi di esecuzione del programma) per ottenere la loro percezione devono essere scomposte dal generale al particolare. Dovrebbero anche includere descrizioni della forma di presentazione e del volume dei dati interni.

Per cominciare, esiste la prima versione del diagramma gerarchico, ottenuto semplicemente suddividendo le funzioni del programma in sottofunzioni, indicando le variabili necessarie per collocare i dati nelle diverse fasi di elaborazione. Piuttosto, questa opzione non è ottimale e sono necessarie iterazioni di progettazione per migliorare la topologia del circuito.

Ogni nuova versione viene confrontata con la precedente secondo i criteri qui descritti. La generazione della variante si interrompe quando non sono possibili ulteriori miglioramenti.

Il fondo dei criteri di ottimalità per gli schemi gerarchici è un aiuto necessario per l'ottimizzazione degli schemi gerarchici e consiste nei seguenti criteri:

• - completezza di svolgimento delle funzioni specificate;
• - la capacità di ricostituire in modo rapido ed economico nuove funzioni precedentemente non specificate;
• - visibilità per il progettista delle componenti del programma;
• - massima indipendenza rispetto ai dati delle singole parti del programma;
• - la possibilità di collegare il programma con un ampio schema gerarchico multilivello con uno specifico linker (linker). Se inizia il lavoro su un nuovo programma, è molto utile eseguire il suo modello su un computer sotto forma di stub di moduli vuoti che non contengono alcuna azione;
• - sufficienza di RAM. Qui le opzioni sono considerate con la descrizione di variabili statiche e dinamiche particolarmente strutturate a diversi livelli dello schema gerarchico. La verifica del soddisfacimento di questo criterio viene effettuata mediante calcoli con alcuni esperimenti di macchina;
• - valutazione dell'influenza della topologia dello schema gerarchico sulla velocità di esecuzione del programma quando si utilizzano gli overlay (caricamento dinamico del programma) e sul meccanismo di paging quando si sviluppa un programma che non può essere interamente localizzato nella RAM;
• - l'assenza di moduli diversi che svolgono azioni simili. Idealmente, lo stesso modulo viene chiamato a diversi livelli dello schema gerarchico;
• - Raggiungimento durante l'attuazione del programma di un tale programma di rete per il lavoro del team di programmatori, che garantisce un carico di lavoro uniforme del team in base alle date chiave del progetto;
• - ridurre in modo completo il costo del test del nucleo già assemblato del programma entro le date chiave del programma di implementazione della rete. Si caratterizza per la semplicità degli stub utilizzati e la qualità dei test lungo tutti i percorsi computazionali dei moduli. È ottenuto dall'implementazione primaria dall'alto verso il basso dei moduli di input e output del programma con un ritardo nell'implementazione dei rami rimanenti dello schema gerarchico. In genere, i costi di test rappresentano circa il 60% del costo totale del progetto. Un buon schema gerarchico riduce i costi di test di 2-5 volte o più rispetto alla versione originale;
• - utilizzare in questo progetto quanti più moduli e librerie possibili sviluppate in progetti precedenti con una quantità minima di parti di nuova produzione;
• - corretta distribuzione dei moduli tra i file di programma compilati e le librerie;
• - accumulo di moduli già pronti e librerie di moduli per il loro utilizzo in tutti i nuovi sviluppi.

In conclusione, si può notare che l'approccio strutturato alla programmazione ha adottato e utilizza molti metodi dal campo della progettazione di sistemi tecnici complessi. Tra questi ci sono l'approccio gerarchico a blocchi alla progettazione di sistemi complessi, le fasi di creazione dei programmi, la progettazione top-down, i metodi di valutazione e pianificazione.