ComputerScience&Co

Esempi di Programmazione in NVIDIA CUDA

2011-10-28T10:04:00.000+02:00

Esempi di programmazione in CUDA.
Download

TIM Olicard 100 su Ubuntu 10.10

2011-04-12T17:22:00.001+02:00

Avendo acquistato la suddetta chiavetta, posto una guida per la corretta configurazione su ubuntu. La prima cosa da NON fare, qualora disponiate di una versione a 32 bit di ubuntu è di non installare il pacchetto presente nella chiavetta. La seconda cosa da non fare è collegare la chiavetta. Prima inseriamo un paio di regole per il corretto riconoscimento del modem. Da un terminale inseriamo prima:

sudo gedit /etc/udev/rules.d/10-OLIdatacarddisk.rules

e inseriamo nel file il seguente contenuto.

KERNEL=="sr[0-9]",SYSFS{idVendor}=="0b3c",SYSFS{idProduct}=="c700",SYMLINK="GKxdatacarddisk",RUN+="/usr/bin/eject -s %k"

Questo permetterà di disattivare l'unita cd associata alla chiavetta (quella contenente i driver di installazione). Alla inoltre vengono associati altri dispositivi: ttyUSB0, ttyUSB1,ttyUSB2,ttyUSB3,ttyUSB4. Quello che interessa a noi è il primo, ttyUSB0. Tuttavia è possibile, specialmente se disponete di un pc con più di un core, che ttyUSB0 non venga registrato come modem, registrando al suo posto una tra ttyUSB2 e ttyUSB3. In questo caso da terminale digitiamo:

sudo gedit /etc/udev/rules.d/11-OLIdatacardmodules.rules

e inseriamo nel file il seguente contenuto:

KERNEL=="ttyUSB[23]",ACTION=="add",SYSFS{idVendor}=="0b3c",SYSFS{idProduct}=="c000",RUN+="/bin/sleep 2"

Se disponiamo di un pc multicore. In ogni caso dobbiamo sempre inserire la seguente riga nello stesso file:

SYSFS{idVendor}=="0b3c",SYSFS{idProduct}=="c000",RUN+="/sbin/modprobe usbserial vendor=0x0b3c product=0xc000"

Che ci permetterà di riconoscere il modem. A questo punto riavviamo e, a sistema completamente carico, inseriamo la chiavetta. Da Network Manager configuriamo una nuova connessione a banda larga mobile (il nostro dispositivo sarà indicato come "0b3c DataCard Device". A questo punto potremmo usare la nuova connessione per collegarci a internet. Se per caso non dovesse connettersi ( verrà mostrato il messaggio "si è ora disconnessi dalla rete") apriamo un terminale e digitiamo:

sudo gedit /var/log/messages

Diamo un'occhiata al log file e assicuriamoci che siano presenti delle voci simili alle seguenti:

usb 2-1.1: generic converter now attached to ttyUSB0
usbserial_generic 2-1.1:1.1: generic converter detected
usb 2-1.1: generic converter now attached to ttyUSB1
usbserial_generic 2-1.1:1.2: generic converter detected
usb 2-1.1: generic converter now attached to ttyUSB2
usbserial_generic 2-1.1:1.3: generic converter detected
usb 2-1.1: generic converter now attached to ttyUSB3
usbserial_generic 2-1.1:1.4: generic converter detected
usb 2-1.1: generic converter now attached to ttyUSB4
usbcore: registered new interface driver usbserial_generic
usbserial: USB Serial Driver coreswitched to 0b3c:c000 (: DataCard Device)

e le seguenti voce nel momento in cui tentiamo di connetterci:

Using interface ppp0
Connect: ppp0 <--> /dev/ttyUSB0

Se in quest'ultima riga, al posto di USB0 appare USB2 o USB3, assicuriamo che il secondo file sia stato creato nel modo corretto (controlliamo bene i doppi apici) ed eventualmente settiamo lo sleep ad un valore più alto (cambiando il 2 con 5 ad esempio).

HighLighting Syntax per Cuda su Scite

2011-04-11T15:37:00.003+02:00

Scaricare il file e sostituirlo a quello presente in Scite. Permette di evidenziare le keyword CUDA.

Download HSCS

Aggiornato il 11/05/2011 ore 19.13.

Il Semantic Web

2011-04-02T21:42:00.001+02:00

La mia tesi di laurea: " I linguaggi del semantic web e applicazione per la catalogazione di reperti archeologici"

Esempi WebProgramming

2010-09-02T18:37:00.000+02:00

esempi svolti di web programming (JavaScript,AJAX,PHP).

Download

N

2010-08-29T20:14:00.005+02:00

Namespace: lo spazio dei nomi è un contenitore logico al quale vengono assegnati degli elementi (identificatori). Un namespace è identificato da una URI. Gli elementi che appartengono al namespace hanno la seguente nomenclatura: la URI del namespace seguito da un separatore e da un nome univoco che identifica l'elemento (local name) per quel namespace . Nei linguaggi di programmazione un namespace è un contenitore logico di variabili.

Esercizi Svolti C#

2010-08-27T10:27:00.000+02:00

Esercizi svolti sul linguaggio C# adatto a chi è nuovo del linguaggio(o della programmazione)

Download

Introduzione a XML

2010-07-04T11:35:00.002+02:00

Introduzione a XML con esempi

Download

ImageSoft

2010-07-02T15:45:00.001+02:00

ImageSoft, un software di elaborazione di immagini digitali

Download

introduzione ad Ajax-JSON

2010-06-25T19:03:00.001+02:00

introduzione ad ajax e JSON con esempi

Download

Introduzione a PHP

2010-06-25T19:02:00.000+02:00

Introduzione a php con esempi

Download

Introduzione a Javascript

2010-06-25T19:01:00.000+02:00

introduzione a javascript con esempi.

Download

Esempi pratici su Java2D

2010-05-26T17:38:00.000+02:00

Raccolta di codici sorgenti che mostrano come si realizzano interfaccie grafiche ed effetti su immagini in java.

Raccolta 1

Raccolta 2 by anonimo

Ultima modifica 28/05/2009 ore 13.54

Utilizzo delle classi Java2D

2010-05-26T17:33:00.000+02:00

Codici sorgenti che mostrano come si utilizzano le classi per il disegno di interfaccie grafiche in Java.

Download

Metodi Formali nel Processo di Sviluppo del Software

2010-04-10T18:11:00.000+02:00

I metodi formali nel processo di sviluppo del software permettono di creare una specifica più completa, uniforme e non ambigua rispetto alle metriche usate tradizionalmente e di ridurre il numero di errori. Tale specifica, basata su cognizioni matematiche, può essere dimostrata, corretta ed eseguita ad alto livello. In questo post ci occuperemo del metodo delle Abstract State Machine per l'analisi e il design del software. Il metodo ASM, permette di seguire il processo di sviluppo dalla raccolta dei requisiti fino all'implementazione, gestendo la dimensione del software, la sua complessità ed affidabilità, permette una modellazione di alto livello accurata, al livello di astrazione attraverso una catena modelli di sistema con livelli di astrazione via via sempre più raffinati. Contrariamente ad UML permette inoltre una maggiore accuratezza. L'Abstract State Machine è un modello di computazione espresso con una notazione rigorosa dal punto di vista matematico e rivolto alla pratica grazie alla sua comprensibilità. Si individuano diverse categorie di ASM: Le Basic ASM, basate su determinismo e parallelismo, idonee per programmi flat; Le Turbo ASM, basate su composizione sequenziale e iterazione, idonee per applicazioni con chiamate ricorsive; Le Multi-Agent ASM (sincrone e asincrone) sono definite come un insieme di agenti che eseguono la loro ASM in parallelo.

Le ABS consistono in un vocabolario ∑, un insieme di stati iniziali, un insieme di regole, un simbolo di regola distinto chiamato "main rule" . Gli stati possono essere visti come delle memorie astratte; il vocabolario

∑ è una collezione finita di simboli funzionali tali che:

ogni simbolo ha una arietà, i nomi di funzione nullari vengono anche chiamati costanti.
i simboli di funzione possono esseer statici ( undef, true, false)
oppure dinamici ( monitorati, condivisi, di output ecc)

Uno stato S sul vocabolario ∑ è una coppia (D,I) dove D rappresenta il dominio e I la funzione di interpretazione dei simboli funzionali in ∑. D è anche chiamato "base set" dello stato, è possibile definire funzioni parziali, una relazione ha sempre valori true,false o undef, nelle applicazioni D viene spesso suddiviso in universi più piccoli. In uno stato i simboli di funzione e gli argomenti delle funzioni sono le locazioni di memoria mentre i valori delle funzioni sono i loro contenuti. Definiamo una "locazione" di uno stato S come una coppia costituita da un simbolo funzionale n-ario f e un insieme di n elementi (a1,...an) del dominio D. Definiamo un aggiornamento per S, una coppia (l,v) dove l è una locazione di S e v un elemento di D. Un insieme di aggiornamenti viene detto consistente se non ha aggiornamenti in collisione, ovvero se per ogni locazione l e tutti gli elementi u,w è vero che se (l,v),(l,w) appartengono all'insieme allora v=w. Se un insieme di aggiornamenti consistente U viene "sparato" in un dato stato allora il risultato è un nuovo stato. In questo nuovo stato rimane inalterato il contenuto delle locazioni non considerate, mentre per ogni (l,v) in U il contenuto della locazione l nel nuovo stato sarà v. Se un insieme di aggiornamenti U consistente viene sparato in un nuovo stato S, il nuovo stato risultante S+U viene determinato univocamente.Le regole di transizione dell'ASM definiscono la sintassi del programma; interpretando il programma nello stato corrente viene determinato un insieme di aggiornamenti che sparati sullo stato corrente realizzano il nuovo stato. Le regole di transizione sono:

skip ,regola di skip

f(s1,...sn) .= t ,regola di Update.

P par Q ,regola di Block.

if t then P else Q ,regola di Condition

let x=t in P ,regola di Let

forall x with y do P , regola di Forall

choose x with y do P ,regola di Choose

Una dichiarazione di regola per un simbolo di regola r di arietà n è una espressione r(x1,...xn)=P , dove P è una regola di transizione e x1,...xn sono le variabili libere di P. In una chiamata ad una regola r(t1,...tn) le variabili xi vengono sostituite con i parametri ti.

Le ASM non prevedono variabili globali. I parametri formali della testa sono le uniche variabili che hanno uno scope globale. Diciamo che una macchina M può fare una mossa da uno stato S ad uno stato T e scriviamo S => T se

se la main rule di M restituisce un insieme di aggiornamenti consistente U partendo dallo stato S e
T = S+U

Gli aggiornamenti in U vengono detti aggiornamenti interni ( per distinguerli dai possibili aggiornamenti di locazioni monitorate o condivise). T viene detto stato interno successivo. La computazione di una ASM comincia nello stato iniziale, non appena viene compiuta una mossa la computazione procede richiedendo solo che le mosse dell'ambiente che aggiornano le locazioni monitorate e condivise producano uno stato nuovo per la mossa successiva. Se uno stato la macchina non può produrre un insieme di aggiornamenti consistente oppure non è in grado di produrre nessun insieme di aggiornamento lo stato viene definito l'ultimo della computazione.

Il collaudo del software

2010-03-30T16:30:00.020+02:00

1.0 Introduzione

Prima di essere consegnato un software dovrebbe essere esente da bug. L'attività che mira a scovare i bug viene chiamata "collaudo". Il collaudo può essere condotto dagli stessi sviluppatori o da dei collaudatori esterni, dai clienti (alpha test) o dagli utenti finali (beta test). Il collaudo noto come "black box" mira a dimostrare la correttezza implementativa dei requisiti funzionali (funzioni errati o inesistenti, errori di interfaccia, errori di strutture dati o nei database esterni, errori di comportamento ecc). Solitamente, quando si parla di test sull'input si mira ad realizzare delle classi di equivalenza,ovvero dei gruppi che riunisco i possibili valori che possono essere passati, senza tentarli tutti. Il collaudo "white box" mira invece ad esaminare i cammini logici del software (ad esempio cosa succede quando tutti i cicli iterativi si chiudono ai casi limiti. Una tecnica di collaudo white box è stata proposta da Tom McCabe basata sulla costruzione di un "grafo di flusso" che rappresenti il flusso di controllo del programma. Lo scopo di questo test è far si che il programma esegua ogni istruzione,completi ogni ciclo iterativo, e valuti tutte le condizioni if/else (vedremo in dettaglio dopo). Un altra tecnica white box è la matrice di adiacenza del grafo di flusso basata sulla costruzione di una matrice rappresentante il flusso del programma i cui pesi (1,0) rappresentano la probabilità che un arco venga percorso. Ogni cella può inoltre essere interpretata come il tempo di elaborazione necessario all'attraversamento di un arco e la quantità di memoria richiesta per farlo. Altre tecniche sono mirate esclusivamente a testare i cicli iterativi (Collaudo per cicli) o i costrutti di selezione (collaudo per condizioni). Vediamo adesso alcune categorie precise di difetti:

1.Esecuzione di un calcolo nella parte errata di un costrutto di controllo: il collaudo per cicli farà eseguire zero,una o più volte un loop per individuare l'errore.

2.Loop Infinito: anche qui il collaudo per cicli può aiutare a scovare la causa di loop.

3.Precondizioni per un algoritmo: ciò che deve essere fatto prima che il controllo passi ad uno specifico algoritmo può causare problemi durante l'esecuzione dell'algoritmo stesso. Il collaudo per condizioni può fare emergere il problema.

4.Null Conditions: quando viene passato un valore null il programma si blocca o si comporta anomalmente. Anche qui risulta utile il collaudo per condizioni e dei testi specifici per scovare eventuale istruzione che assegna il valore null.

5.Off-by-one errors: Cicli eseguiti troppe volte o poche volte non producono i risultati attesi. La soluzione consiste in test mirati e collaudi per cicli.

6.Errore di precedenza degli operatori: Soluzione basata sull'ispezione del codice e sul test dei micro-moduli.

7.Algoritmi numerici: strutture dati o variabili troppo piccole per contenere i dati necessari: Soluzione basata sul testare l'input con valori grandi o grandi mole di dati.

8.Errori di parsing: passare al programma ciò che non si aspetta. Soluzione basata sul test dei micromoduli e dell'input.

9.Linguaggi orientati agli oggetti: In questo caso bisogna usare combinazioni di collaudi white box e black box, test mirati delle procedure e dei metodi, test sui micromoduli. Bisogna collaudare anche l'interazione tra le varie classi, basandosi anche sui modelli comportamentali per meglio comprendere come esse interagiscono. Solitamente si procede testando le singole classi e sistematicamente si aggregano altre classi per essere testate insieme (soluzione bottom-up) o in alternativa si testano prima insiemi di classi per poi passare al test delle singole classi (soluzione top-down). Se il software ha subito modifiche,gli stessi test condotti nella versione precedente vanno rieseguiti per assicurare la stabilità e la correttezza delle modifiche stesse. Se si ricorre a collaudatori esterni bisogna fornire una descrizione dettagliata del test da effettuare, dello stato iniziale e finale del sistema, dei risultati attesi. Inoltre il collaudatore non deve essere influenzato dalla struttura interna del software e non deve essere a conoscenza dei meccanismi interni altrimenti la sua capacità di operare potrebbe subirne influenza.

2.0 Grafi di flusso e complessità ciclomatica

Il grafo è una struttura che ben si adatta a rappresentare il flusso del software. Per stimare il numero massimo di collaudi da effettuare per testare ogni istruzione del programma (cioè eseguire almeno una volta ogni singola istruzione, il metodo non comprende test sugli input!) bisogna calcolare la complessità ciclomatica. La complessità ciclomatica è il numero di cammini linearmente indipendenti nel grafo). Esistono diversi metodi per effettuare il calcolo; sia V(G) la complessità ciclomatica, N il numero di nodi, E gli archi, P le componenti connesse. V(G) sarà allora dato da

1) V(G)=R=E-N+2 ; in questo caso V(G)=R cioè la complessità ciclomatica è uguale al numero delle regioni (cioè le zone che gli archi e i nodi formano).
2) V(G)=E-N+2P;
3)V(G)= π+1; π è il numero di predicati (cicli for-while e if-else,AND,OR ecc).

Costruito il grafo e calcolata la complessità ciclomatica è possibile costruire i casi di test che seguano i cammini linearmente indipendenti del grafo.

3.0 Collaudo d'interclasse e di integrazione

E' fondamentale testare i componenti dal punto di vista dell'interfacciamento con altre componenti. Solitamente questa categoria di test viene scritta a partire dai modelli comportamentali. Dopo aver testato i componenti singolarmente questi devono essere aggregati per ottenere il software finale, questa fase prende il nome di integrazione delle componenti. Esistono tre approcci ai test di integrazione:

Collaudo:BingBang; si costruisce tutto il software e poi si testa nella sua interezza.E' una tecnica sconsigliata il più delle volte perchè non mette in evidenza gli errori meno visibili.
Collaudo Incrementale: le componenti vengono aggregate poco per volta (solitamente due componenti per volta) e la componente risultante viene testata singolarmente, poi si procede iterativamente. Può essere Top-Down ( si parte dal modulo principale al quale vengono aggregate via via le componenti di basso livello); Bottom-Up: si parte dalle componenti di basso livello e si termina con il modulo principale.
Collaudo per Regressione: questo genere di collaudo avviene sempre dopo il collaudo di tipo 1. o 2. e mai da solo. Consiste nel ripetere test svolti durante le prime fasi del collaudo (test ai singoli componenti o test di aggregazione) per confermare che le modifiche effettuate per l'integrazione non abbiano ottenuto effetti indesiderati.

Quando un test viene documentato vanno inserite le seguente informazioni:

ID e titolo descrittivo del test; va indicata l'importanza del test, il sistema,sottosistema o modulo testato deve essere chiaramente indicato facendo riferimento anche ai documenti di specifica dei requisiti e architetturale.
Istruzioni del collaudatore: cosa e come fare, come mettere il sistema nello stato iniziale e quale input fornire.
Risultato Atteso: cosa ci si aspetta dal test, ovvero come si dovrebbe comportare il sistema se non vi fossero bug o errori.
CleanUp: come arrestare il sistema dopo il test o riportarlo allo stato precedente all'esecuzione del test.
Risultato: il risultato del test e se l'esito è negativo riportare l'errore (o il bug).

La Seconda Fase del Progetto:Modello Analitico e Progettuale.

2010-03-29T22:20:00.002+02:00

1.0 La modellazione Analitica

La modellazione analitica prevede la revisione di tutti i requisiti (funzionali e non), la definizione degli scenari, degli attori, la modellazione del flusso dei dati, delle classi analitiche e della loro organizzazione, la modellazione comportamentale e la revisione dei diagrammi per verificarne la correttezza e la precisione.

La modellazione basata sugli scenari permette di comprendere come l'utente interagisce con il sistema e di costruire dei modelli analitici e progettuali in base alla specifica dei requisiti. Si utilizzano due tecniche:

I casi d'uso: descrivono una specifica situazione in cui l'utente interagisce con il sistema, dal punto di vista di un attore ben definito.Un attore può essere una persona fisica o uno strumento che utilizza il sistema.
Diagramma di attività: affianca il caso d'uso fornendo una rappresentazione grafica del flusso di interazioni nella situazione specificata.
Diagramma SwimLane: rappresenta il flusso di attività di un caso d'uso permettendo di individuare l'attore o la classe analitica che ha responsabilità per l'azione descritta.

La modellazione basata su classi permette di identificare le classi analitiche, gli attributi e le operazioni che definiscono il comportamento di un oggetto. Il modello comportamentale rappresenta invece come il sistema risponderà a stimoli o eventi esterni. Viene rappresentato mediante diagrammi di stato e di sequenza.

2.0 Modellazione Progettuale

La modellazione progettuale sfrutta il modello analitico selezionando una architettura appropriata per il software, crea le classi e le componenti del progetto, traducendo ogni descrizione di una classe analitica in una classe progettuale, definendo i metodi associati a ciascuna classe i problemi di ereditarietà, progetta ogni interfaccia necessaria per i sistemi o dispositivi esterni,l'interfaccia utente, specifica la sequenza di attività in base a gli scenari utente, crea un modello comportamentale dell'interfaccia, specifica gli algoritmi a un livello di astrazione basso, le strutture dati e revisiona ciascun componente. La modellazione progettuale deve essere una conseguenza diretta del modello analitico e deve essere incentrata sull'architettura e sul design dei dati.

Design dell'interfaccia

2010-03-29T21:56:00.000+02:00

Una interfaccia è bene realizzata se essa risponde all'esigenze di coloro che la devono utilizzare. Solitamente essa deve essere facile da imparare,semplice da usare e da capire, deve nascondere i meccanismi interni che la alimentano e deve essere uniforme e in linea con le abitudini e le abilità dell'utente. Non Dovrebbe inoltre non fare uso intesivo della memoria principale. Per tali motivi bisogna prima individuare il tipo di utente destinatario (esperto, tecnico,impiegato ecc), capire le sue necessità e le sue abitudini,comprendere l'ambiente in cui opera e le attività di cui si devono occupare. Bisogna inoltre capire se sono in grado di accedere a funzioni avanzate, se sono abili nell'uso della tastiera, dei tasti di scelta rapida e così via. Utilizzando queste informazioni si può produrre un disegno preliminare e fornire un primo prototipo. In base ai test prodotti e alla valutazione del cliente stesso, i vari prototipi possono essere sviluppati fino al raggiungimento del prodotto finale. Gli errori in cui si incappa spesso durante la realizzazione dell'interfaccia sono i seguenti:

Tempi di risposta eccessivi.
Menù e comandi poco intuitivi.
Errori nell'esecuzione dei comandi
Scarsa accessibilità dell'applicazione.
Problemi di Internazionalizzazione.
Interfaccia poco intuitiva, a volte frustrante.

Gestione delle Configurazioni Software

2010-03-29T21:35:00.001+02:00

Il processo di gestione della configurazione software è un attività ausiliaria con lo scopo di riconoscere, gestire e controllare il cambiamento nel software informando gli interessati. La gestione deve godere di alcune proprietà:

Gestione delle versioni: ogni versione deve essere archiviata permettendo ai programmatori di fare il downgrade quando necessario.
Monitoraggio delle dipendenze: i cambimenti delle dipendenze devono essere archiviati.
Monitoraggio dei requisiti: i cambiamenti nei requisiti devono essere opportunamente monitorati.
Gestione della configurazione: le configurazioni rappresentano rappresentano specifici risultati del processo.
Audit Trail: bisogna tener conto di chi,quando e perchè ha portato ad un cambiamento.

Un sistema per il controllo delle versioni deve prevedere un database di progetto per catalogare tutti gli oggetti di configurazione rilevanti, deve permettere di gestire le diverse versione consentendo all'ingegnere del software di raccogliere tutti gli oggetti al fine di costruire una specifica versione del software. Anche i bug presenti nelle diversi versioni vanno monitorati. Il controllo di cambiamento prevede diverse fasi. Una volta riconosciuta l'esigenza di una modifica e approvata si assegna del personale al compito, vengono raccolte le informazioni dagli archivi, si procede alla modifica e ai testi, si registrano e si archiviano i nuovi cambiamenti. Il diagramma di flusso è il seguente:

1.Richiesta di modifica dall’utente
2.Lo sviluppatore valuta la richiesta
3.Si produce una relazione
4.L’autorità di controllo delle modifiche decide
5.a.La richiesta è posta in coda oppure
5.b.Richiesta respinta e l’utente viene informato.
6.Si riconosce l’esigenza di una modifica
7.Assegnazione del personale agli SCI
8.Estrazione degli SCI dall’archivio
9.Modifica
10.Revisione del cambiamento
11.Documento acquisito per il collaudo
12.Esecuzione SQA e collaudo
13.Ratifica delle modifiche da iincludere nella nuova versione
14.Costruzione della nuova versione del software
15.Revisione per tutti gli elementi della configurazione
16.Inserimento delle modifiche nella nuova versione

Piano di Gestione della Qualità

2010-03-27T17:08:00.001+01:00

1.0 Introduzione

Il piano di gestione della qualità ha lo scopo di pianificare,controllare e migliorare la qualità del prodotto. Per qualità generalmente si indica la conformità del prodotto ai requisiti, alle pratiche e alle politiche stabilite e alle proprietà che i consumatori percepiscono essere di alta qualità. La fase di pianificazione prevede di stabilire le intenzione e l'atteggiamento del team riguardo la qualità del prodotto. I fattori di qualità, individuati da McCall sono:

Correttezza: grado di aderenza del software alle specifiche
Efficienza: quantità di risorse e di codice necessarie perché il programma adempia alla propria funzione
Affidabilità: grado con cui un programma svolge la propria funzione con la precisione richiesta. (tolleranza all’errore, accuratezza, semplicità)
Integrità: grado con cui è possibile controllare l’accesso al software o ai dati da parte di persone non autorizzate. (controllo e valutazione degli accessi)
Facilità d’uso: indical’impegno necessario per imparare a usare il software, a prepararne i dati d’ingresso e a interpretarne i dati d’uscita.
Facilità di manutenzione: misura l’impegno necessario per localizzare e correggere un errore nel programma
Flessibilità: misura l’impegno necessario per modificare il programma
Collaudabilità: misura l’impegno necessario per stabilire, tramite collaudo, se un programma svolge la funzione prevista
Portabilità: misura l’impegno richiesto per trasportare un programma da un ambiente hardware o software, a un altro.
Riutilizzo: misura il grado con cui un programma (o alcune sue parti) può essere utilizzato di nuovo in altre applicazioni.
Interoperabilità: misura l’impegno richiesto a far interagire il programma con altri programmi

Un buon piano di qualità inoltre deve includere anche le seguenti attività:

Selezione delle pratiche per la garanzia di qualità: identificazione di tool specifici e tecniche per il monitoraggio della qualità dello sviluppo del software.
Valutazione del piano di progetto software: è una delle revisioni più importanti e difficili da condurre
Accettazione della valutazione dei requisiti: definisce le caratteristiche di un prodotto accettabile.4.
Valutazione della specifica: valuta se le specifiche sono conformi alle attese.
Valutazione del processo di design: valuta se il processo di design è conforme alle attese6.
Valutazione delle pratiche di codifica: come sopra per la codifica.
Valutazione del processo di test ed integrazione: come sopra per test ed integrazione.

Lo scopo delle revisione è individuare gli errore nel processo di sviluppo del software e bloccarne la propagazione. Solitamente il team si riunisce in piccoli gruppi per analizzare parti specifiche e relativamente piccole del software al fine di effettuarne una valutazione. Tutte le revisioni verranno registrate e documentate. Disponendo di una descrizione rigorosa dei requisiti è possibili ricorrere a dimostrazioni formali per verificarne la correttezza. Le revisioni formali sono note con il nome di Quality Gate.

2.0 Quality Gate

Il processo di verifica è basato su checklist (risposte vero o falso su domande standard). Per il processo di sviluppo la checklist è:

La portata del software è definita in maniera chiara?
La terminologia è ben definita?
Le risorse sono ragionevoli? Sono disponibili?
L’analisi dei rischi è stata fatta? E il piano contenimento e/o prevenzione?
I compiti sono stati definiti, programmati e allocati?
Le stime di costo e programmazione sono ragionevoli?
E’ stato applicato uno standard nella stesura della documentazione?
Come sarà controllato il piano del progetto?
E’ necessario un ambiente per lo sviluppo del software?
Come è stata condotta la revisione?

Per i requisiti software invece:

Tutte le funzioni sono state definite, descritte, vincolate in maniera non ambigua?
Per ogni requisito funzionale è stato introdotto anche un requisito di performance, e il requisito funzionale è testabile?
Gli input e gli output sono stati tutti definiti in termini di range, protocolli,.. in modo che il designer del software possa essere soddisfatto?
E’ stato fatto un piano di test e di integrazione? I criteri di accettazione dei test sono stati già negoziati con il cliente?
Lo studio di fattibilità è completo?
L’analisi dei rischi è stata iniziata/completata?
Sono stati applicati degli standard alla documentazione?

Per la specifica architetturale:

Ci sono ancora dei requisiti aperti? Se sì, si progetta di chiuderli?
Il partizionamento è completo e documentato?
Tutte le interfacce hardware e software interne ed esterne sono state definite adeguatamente in termini di protocolli, range ecc..?
Il modello dei dati è stato completamente e accuratamente definito?
I requisiti software di basso livello sono tracciati nei requisiti software di alto livello in maniera completa ed accurata?
Possono essere soddisfatti i requisiti non funzionali?
Il partizionamento soddisfa i criteri di modularità?
Sono state definite le interfacce fra i moduli?
Il design della struttura dati è consistente con i requisiti dei dati?
Manutenibilità e flessibilità sono attributi di qualità considerati nel design?
Quali attributi di qualità sono applicati?
Gli standard di documentazione sono stati raggiunti?
Sono stati applicati degli standard nella pseudocodifica? Se sì, come sono stati applicati?

Per la specifica di dettaglio:

Sono stati tenuti in considerazione tutti i requisiti?
La specifica dettagliata è consistente con la precedente?
Lo pseudocodice o i diagrammi sono stati correttamente trasformati in codice? Hanno soddisfatto gli standard richiesti?
Sono stati soddisfatti gli standard per la documentazione?
I commenti soddisfano degli standard?
I tipi di dati e la dichiarazione dei dati è corretta?
I dati sono corretti?
Sono stati tenuti in conto gli attributi di qualità?

Per il testing

I criteri di accettazione dei test sono stati definiti, negoziati ed accettati? Le revisioni sono state fatte come richiesto?
I piani di test sono stati preparati e revisionati?
L’attività di testing è stata presa in considerazione in altre fasi di sviluppo?
Gli ambienti di test (strumenti e risorse) sono definiti in maniera adeguata e disponibili quando necessario?
La tracciabilità fra requisiti e test di conferma è stata completata e corretta?
Le funzioni principali sono confermate presto nella fase di testing?
Sono stati definiti degli standard per condurre i test? I tester sono stati sottoposti a training?
Sono stati definiti test limite e test di stress?
Il testing è fatto in maniera completa?
La gestione degli errori e delle eccezioni è stata testata?

Per la valutazione della revisione:

Il materiale è completo?
Il materiale è stato distribuito in tempo?
Gli standard applicabili sono disponibili?
I partecipanti erano preparati a contribuire?
La valutazione è iniziata in tempo?
La revisione è stata condotta attraverso protocolli standard?
E’ stato identificato un certo numero di difetti?
Sono stati riportati gli attributi di qualità?
Si e’ cominciato a tracciare i difetti?

3.0 Capability Maturity Model

Il Capability Maturity Model è il più famoso modello di valutazione e miglioramento.Ogni processo è caratterizzato da tre proprietà: La capability, l'insieme dei risultati che un processo consente di conseguire; performance, la misura dei risultati effettivi ottenuti nell'applicazione del processo; maturity,l’efficacia del processo e della estensione e precisione con cui le fasi e le attività dello stesso sono esplicitamente definite, gestite, misurate e controllate. Sono individuati 5 livelli di maturità: iniziale,ripetibile,definito,controllato e ottimizzato. Ad ogni livello è associata una previsione di performance. Quando il livello è iniziale, il processo di produzione è instabile e disorganizzato per cui nulla è prevedibile.Al livello ripetibile, esiste già una struttura in grado di gestire costi,scheduling delle attività ed i cambimenti che vengono apportati. Al livello definito, il processo è ben fondato su metodologie e tecniche di ingegneria del software sia per quanto riguarda gli aspetti operativi che quelli manageriali. Al livello gestito, il processo produttivo un dettagliato piano di misura per il controllo della qualità del processo e del prodotto. Al livello ottimizzato,è stata istituzionalizzata una politica di gestione della qualità. Il CMM prevede inoltre per l'accertamento una checklist da tarare ed adottare in base alle realtà aziendali.

Il Piano di Progetto

2010-03-24T11:20:00.002+01:00

1.0 Generalità

Il piano di progetto è un documento versionato redatto dal project manager allo scopo di stimare i tempi. i costi e le risorse necessari alla realizzazione del progetto. Si divide in due parti, La Pianificazione, per pianificare le attività future, e La Consuntivazione,per avere un riscontro tra le attività pianificate e quelle effettuate. Il piano di progetto comprende:

Definizione degli Obbiettivi.
Analisi dei Rischi
Descrizione del modello di processo di sviluppo.
Suddivisioni in milestone.
Attività di progetto.
Stima dei costi.
Consunto di attività.

Chiameremo Attività un lavoro svolto nel progetto, con una durata e un costo ben preciso. Chiameremo invece Deliverable un risultato che deve essere prodotto per completare un progetto o una sua parte.

2.0 Work BreakDown Strucutre (WBS)

Il WBS è un di elementi del progetto che definisce i limiti complessivi del progetto, ovvero tutto ciò che è dentro i limiti del progetto. E' rappresentato da una struttura gerarchica in cui ogni livello discendente rappresenta una descrizione più dettagliata dell'elemento del progetto. Per costruire un WBS si parte dai deliverable principali, che nello schema rappresentano la radice. Se per il deliverable non siamo in grado di stimare costo e durata, si passa a un successivo livello di dettaglio, rappresentato da un discendente. Ad ogni elemento viene associato un identificatore univoco, gli elementi più in basso nella gerarchia sono chiamati work packages. Le attività che devono essere eseguite per produrre i deliverable vanno identificate e documentate. Ogni attività è descritta da risorse utilizzate e relativi documenti in input, durata (in giorni), costi e realtivi documenti in output, legami di precedenza con altre attività e figura responsabile. Per ogni attività va individuata la dipendenza con altre attività. Si indiviudano tre tipi di dipendenze. Le dipendenze obbligatorie, inerenti alla natura del lavoro che deve essere fatto; le dipendenze discrezionali, definite ed imposte dal team. Questo tipo di dipendenze va documento con attenzione in un documento chiamato Best Practices;le dipendeze esterne, che coinvolgono attività di progetto e non. Le dipendenze vengono rappresentate con un diagramama di precedenza, composto da noti collegati da frecce, in cui i nodi collegati sono le attività legate da dipendenza e la freccia rappresenta il verso della dipendenza (chi dipende da chi). Calcolare il tempo previsto per il completamento del progetto è una operazione affidata a membri con alta esperienza. Solitamente si analizza il percorso critico del progetto (l'attività con minore flessibità di stima) e si sommano i tempi di tutte le attività. Le attività e i relativi tempi sono illustrati graficamente in uno schema chiamato Slack Time. Le attività possono sollevare conflitti nei casi in cui i loro slack time stessi sono in conflitto. Solitamente si tenta di realizzare le attività con slack maggiore, si ridistribuiscono le risorse o si frammentano le attività.

3.0 Modello COCOMO

Il modello COCOMO (Constructive Cost Model) è un metodo di stima dei costi di sviluppo di un software. Esso prevede che il processo di sviluppo del software sia basato sul modello a cascata. Esso comprende tre diversi livelli di stima. Stima di base, approssimata,veloce,scarna di dettagli limitata dalla mancanza di informazioni più precise circa il progetto; Stima intermedia maggiormente accurate e dettagliate, usufruisce di informazioni quali ambiente di sviluppo e altri parametri;Stima Dettagliata, fornisce la stima migliore in quanto usufruisce di tutte le informazioni sul progetto e sulle sue fasi.

Il modello CoCoMo di base distingue tre modalità di sviluppo del software: Organic mode, il team di sviluppo consiste di un numero piccolo di sviluppatori di esperienza che hanno familiarità con l’area di applicazione e con l’ambiente di sviluppo,inoltre e dimensioni del prodotto sono piccole o medie; semidetached mode, il team di sviluppo consiste di un misto di persone con e senza esperienza, che lavorano insieme da poco,la dimensione del prodotto può essere media o grande;Embedded mode,richiede un elevata quantità di risorse,il prodotto ha requisiti stringenti riguardo ad affidabilità, performance,schedule ed interfacce,la dimensione del prodotto è media o grande e generalmente complessa. Il modello CoCoMo intermedio mantiene le stesse distinzioni del modello di base ma introduci 15 nuovi Cost Driver. Il modello dettagliato invece tiene conto dei Cost Drivers del modello precedente ma in funzione delle varie fasi di sviluppo del software. Negli anni '90 fu introdotto il modello CoCoMo II per adattarsi ai nuovi processi di sviluppo come riuso, composizione e paradigmi orientati agli oggetti.

La prima fase del progetto: L'Analisi

2010-03-17T17:23:00.001+01:00

1.0 L'analisi del Dominio

Studiare e comprendere bene il dominio del problema da affrontare costituisce il primo passo verso lo studio della fattibilità e della comprensione dei requisiti. Le informazioni necessarie a tale scopo posso essere acquisite in modi diversi, interviste a clienti, documentazioni presenti o di progetti passati, soluzioni già note a problemi affrontati in passato. L'analisi del dominio è un documento vitale per la stesura del documento successivo, l'analisi dei requisiti, solitamente è versionato ma può essere mantenuto in forma unica e viene diviso in aree:

Visione generale sulla società committente, breve descrizione del prodotto richiesto, ecc
Glossario (definizioni, acronimi, abbreviazioni)
Conoscenze generali sul dominio
Caratteristiche dei clienti e degli utenti
L’ambiente di utilizzo
Compiti e procedure attualmente eseguiti
Software competitori
Similarità ad altri domini

2.0 Verso i requisiti

Il passo successivo è stabilire la portata del software., ovvero il contesto in cui si inserisce il software, i dati trattati (input e output), come trasforma l'input in output (funzionalità) e con quali prestazioni. E' una fase critica in quanto può portare al fallimento del prodotto se il team non comprende realmente le esigenze del cliente, e quindi la portata del software è stata mal elaborata, le funzionalità sono state mal elaborate e vanno quindi modificate diverse volte nel corso della realizzazione del progetto. Barry Boehm chiamò W5H2 le sette domandi da porsi in fase di stesura della portata. Esse sono:

Perchè il sistema deve essere realizzato ?
Cosa deve fare ?
Quando sarà completato ?
Chi sono i responsabili ?
Come sono organizzati ?
Come sarà fatto il lavoro dal punto di vista tecnico e manageriale ?
Quante e quali risorse richiede ?

3.0 L'analisi dei Requisiti

Individuiamo due tipi di requisiti. I requisiti funzionali, che rappresentano le caratteristiche che ci si aspetta dal prodotto, senza i quali lo stesso prodotto non ha senso di esistere, ed i requisiti non funzionali, ovvero tutti i requisiti relativi a tempi di consegna (requisiti temporali), budget economico a disposizione del cliente (requisiti economici), disponibilità del servizio offerto dal prodotto, efficienza e carichi elaborativi (requisiti di servizio), responsabilità organizzativa (requisiti organizzativi), architettura, espandibilità, modularità, interoperabilità ed riusabilità ( requisiti di progettazione),caratteristiche di sicurezza (requisiti di sicurezza),specifiche tecnologiche (requisiti tecnologici), usabilità, documentazione, supporto e formazione (requisiti di utilizzo). Ogni requisito deve essere caratterizzato da:

Numero: identificatore univoco per il requisito
Tipo: categoria a cui il requisito appartiene (organizzativo,economico ecc)
Descrizione: dettagli aggiuntivi
Richiedente: chi ha espresso il requisito.
Data: data di espressione del requisito.
Importanza: quanto è importante per il richiedente (abbastanza,molto,indispensabile ecc)
Priorità: entro quanto tempo il requisito deve essere implementato
Interrelazione: con quali altri requisiti, il requisito ha relazione
Status: grado di stabilità del requisito (in progettazione,verificato,implementato,proposto)

4.0 Analisi dei Punti Funzione

L'analisi dei punti funzione è un metodo volto a suddividere un programma in moduli più piccoli al fine di poterli analizzare meglio. Sono un tipo di misura capace di misurare un'applicazione dal punto di vista dell'utente riuscendo a ricavare un indice delle dimensioni dell'applicazione a partire dalle funzionalità che deve fornire. In particolare misurano le funzionalità dell'utente il ritmo di sviluppo e di mantenimento a prescindere dalla tecnologia con cui si implementa il prodotto, consentono di convertire la dimensione, in linee di codice, dell' applicazione in qualsiasi linguaggio nella dimensione dell’applicazione equivalente scritta in un altro linguaggio, consentono di misurare la produttività di un progetto scritto usando più linguaggi di programmazione. Un software è essenzialmente un insieme definito di processi elementari che interagiscono combinandosi tra loro. In una applicazione software individuiamo dati in movimento (external input, external output, external
inquiries) e dati in riposo (internal logic file, external interface file). Il numero di punti funzione per input rappresenta la produttività software. Può essere migliorata incrementando gli output con gli stessi input, decrementando gli input con gli stessi output, decrementando gli input incrementando gli output. Il conteggio dei punti funzione avviene seguendo diverse fasi: 1) determinare il tipo di conteggio ( sviluppo, miglioramento, applicazione). 2) Determinare i confini dell'applicazione. Il confine indica il limite tra l'applicazione che viene misurate e le applicazioni esterne. 3) Identificare e valutare i tipi di funzione di transizione per determinare il loro contributo al conteggio dei punti funzione. 4)Identificare e valutare i tipi di funzione dato per determinare il loro contributo al conteggio dei punti funzione. 5)Determinare il valore del fattore di aggiustamento. 6) Effettuare i calcoli. Individuiamo alcune funzioni standard:

Data Functions: Internal logical files, dati mantenuti all'interno del confine dell'applicazione
External interface files, dati mantenuti all'esterno del confine dell'applicazione
Transactional Functions: External Inputs, processo elementare proveniente dall'esterno del confine
External Outputs, processo elementare che invia dati all'esterno
External Inquiries, processo elementare che controlla informazioni fuori dal confine

Tutte queste componenti vengono valutate in base a:

Record Element Type: sottogruppo di dati riconducibili dall'utente ad un IEF o EIF
File Type Referenced: file a cui si fa riferimento attraverso una transizione.
Data Element Type: campo unico riconoscibile dall'utente.

Il fattore di aggiustamento è basto su 14 caratteristiche generali di sistema , ogni caratteristica ha delle descrizioni associate per determinare i gradi di influenza, su scala da 0 a 5. Le caratteristiche generali di sistema (GSC) possono così essere elencate:

General System Characteristic Brief Description

• 1. Data communications How many communication facilities are there to aid in the transfer or exchange of
information?
• 2. Distributed data processing How are distributed data and processing functions handled?
• 3. Performance Did the user require response time or throughput?
• 4. Heavily used configuration How heavily used is the current hardware platform where the application will be executed?
• 5. Transaction rate How frequently are transactions executed daily,
weekly, monthly, etc.?
• 6. On-Line data entry What percentage of the information is entered On-Line?
7. End-user efficiency Was the application designed for end-user efficiency?
• 8. On-Line update How many ILF’s are updated by On-Line transaction?
• 9. Complex processing Does the application have extensive logical or mathematical processing?
• 10. Reusability Was the application developed to meet one or many user’s needs?
• 11. Installation ease How difficult is conversion and installation?
• 12. Operational ease How effective and/or automated are startup,back up, and recovery procedures?
• 13. Multiple sites Was the application specifically designed, developed, and supported to be installed
at multiple sites for multiple organizations?
• 14. Facilitate change Was the application specifically designed, developed, and supported to facilitate change?

5.0 Analisi dei Rischi

Durante lo sviluppo del software è possibile incorrere in numerose aree di rischio. Un ingegnere del software deve poter sviluppare dei metodi per individuare e gestire i rischi. Alcune aree di rischio di possono essere personale non adeguato o in numero insufficiente, budget non realistico, sviluppo di funzioni software errate, sviluppo di interfaccia utente errata, instabilità dei requisiti. Il fattore di rischio può essere modellato da due variabili: PF, probabilità di fallimento, CF, conseguenza del fallimento. Il fattore di rischio sarà allora dato da:
RF = PF + CF – PF*CF

Arrivare a un valore per ogni fattore richiede un’analisi completa del fattore e una solida base di esperienza. Di fatti l'assegnamento dei pesi è altamente soggettivo.

Macchina di Turing

2010-03-12T23:58:00.001+01:00

Download

Grammatiche Regolari

2010-03-12T23:57:00.002+01:00

Download

Grammatiche Context-Free

2010-03-12T23:57:00.001+01:00

Download

Automi a Stati Finiti

2010-03-12T23:56:00.001+01:00

Download

Introduzioni alle Basi Teoriche dell'Informatica

2010-03-12T23:55:00.002+01:00

Download

Cammini Minimi in Grafi Orientati

2010-01-29T18:09:00.000+01:00

Appunti su Cammini Minimi in Grafi orientati

Download

Metodologia Greedy (Algoritmi Golosi)

2009-12-19T13:33:00.002+01:00

Introduzione alla Metodologia Greedy (Algoritmi Golosi)

Download 1

Download 2

Network Simulator 2, Cenni

2009-12-10T16:06:00.011+01:00

Network Simulator 2 è un simulatore di reti scritto in C++ e OTCL. Per poter realizzare una simulazione è necessario impostare mediante uno script uno scenario caratterizzato da nodi di trasmissione con relativi buffer e linee di uscita con una certa capacità, tempo di arrivo e lunghezza dei pacchetti, numero di pacchetti per nodo, ritardo dei pacchetti, topologia della rete da simulare,sorgenti di traffico,perdita di pacchetti ecc. Il simulatore fornirà, avviata la simulazione, un trace-file da analizzare, mediante l’analisi del quale otterremo i dati da rappresentare. La simulazione può avere una durata variabile secondo la complessità del modello. Per potere rappresentare lo scenario ns fornisce diversi oggetti che dovremo accuratamente utilizzare. Essi sono nodi, link, agenti di trasporto, generatori di traffico e ricevitori, applicativi. Bisogna tenere in considerazione, durante le simulazioni, della possibilità di perdita di pacchetti dovuta a errori di trasmissione sui link, eccessivo traffico, ritardi e sottodimensionamenti delle code e così via. Per le code vanno tenuti in considerazione la politica di gestione della coda, degli arrivi dei pacchetti (processo degli arrivi), lunghezza dei pacchetti e capacità dei link (processo dei tempi di servizio). Tra le politiche di gestione dei pacchetti individuiamo:

DropTail: i pacchetti vengono elaborati secondo l’ordine di arrivo nella coda

SFQ (Stochastic Fair Queue): si cerca di fornire una distribuzione statisticamente uguale ai pacchetti servendo in maniera equa le sorgenti

DRR (Deficit Round Robin): ogni sorgente ottiene un quanto di bit da trasmettere.

RED (Random Early Detection): si cerca di determinare la soglia di saturazione prima della saturazione stessa e si scartano i pacchetti provenienti da tutti i flussi prevenendo la congestione.

La componente OTCL di NS permette di definire le classi OTCL direttamente connesse alle classi C++, fornisce i metodi per accedere a tale classi e consente di instanziare gli oggetti che compongono il modello da simulare. Vediamo come utilizzare le classi NS:

2.0 Iniziare con NS

La prima cosa da fare è instanziare lo schedulatore del simulatore ed è sempre la prima istruzione da inserire:

set nome_simul [ new Simulator]

Possiamo poi instanziare i nodi:

set primo_nodo [$nome_simul node]

set secondo_nodo [$nome_simul node]

e i relativi agenti:

set primo_agente [ new tipo_agente]

set secondo_agente [ new tipo_agente]

Gli agenti vanno poi collegati ai relativi nodi

$nome_simul attach-agent $nome_nodo $nome_agente

E connessi tra loro

$nome_simul connect $primo_agente $secondo_agente

Due nodi possono essere collegati con il comando

$nome_simul duplex-link $primo_nodo $secondo_nodo dimensione_banda tempo_transito tipo_coda

Possiamo poi instanziare l’applicazione

set nome_applicazione [new tipo_Applicazione]

e collegarlo all’agente

$nome_applicazione attach-agent $nome_nodo $nome_agente

Possiamo poi avviare l’applicazione ad un tempo stabilito, ad esempio 0.1

$nome_simul at 0.1 “$nome_applicazione start”

E terminarla al tempo 0.3 con il comando

$nome_simul at 0.3 “exit”

Tutto quello che abbiamo visto fino ad ora lo potete trovare sul primo file di esempio presente nell'archivio.

Adesso facciamo partire il simulatore. Il simulatore avrà bisogno di un tracefile opportunamente gestito.Apriamo il tracefile di NAM come un comune file in sola scrittura:

set nome_file [open out.nam w]

E associamolo al simulatore

$nome_simulatore namtrace-all $fd

Sarà necessaria una procedura per gestire la chiusura del tracefile e la sua esecuzione. Potete trovare la procedura sul file di esempio presente nell'archivio. La prima cosa che la procedura dovrà fare sarà accedere al tracefile mediante il comando

global nome_simulatore nome_file

Dovrà poi svuotare il buffer con:

$nome_simulatore flush-trace

Dopo dovrà chiudere il file ed eseguire NAM su di esso

close $nome_file

exec nam out.nam &

exit 0

Nell'esempio allegato sarà mostrata la procedura che non ricorre a variabili globali.Dopo la chiusura della nostra applicazione, possiamo eseguire la procedura finish e avviare il simulatore con il comando:

$nome_simulatore run

Estendiamo l'esempio precedente impostando le regole di routing.Per impostare il protocollo di routing unicast si utilizza il comando:

$nome_simul rtproto Static per il routing statico (default)

$nome_simul rtproto Session per il session routing

$nome_simul rtproto DV $nodo1 ….. $nodoN per il Distance Vector routing sui nodi

$nome_simul rtproto LS $nodo1 $nodo2 per il Link State Routing

Per il multicast, dopo aver instanziato il simulatore eseguiamo il comando

$nome_simul multicast

e il comando

$nome_simul mrtproto type

dove type è:

CtrMcast per il Centralized Multicast

DM per il Dense Mode Multicast

ST per il Shared Tree Mode Multicast

BST per il Bi-directional Shared Tree Mode Multicast

Occupiamoci adesso della perdita dei dati. Dobbiamo creare un modello per gestire la perdita dei dati:

set nostro_modello [new ErrorModel]

E configuriamo il rate di perdita (specificando un valore x)

$nostro_modello set rate_ x

Possiamo indicare l'unità e la variabile casuale

$nostro_modello unit type

$nostr_modello ranvar type

E impostare il target

$nostro_modello drop-target type

Nell'archivio è presente un esempio sull'uso di questi comandi. Fino ad ora abbiamo utilizzato il prot TCP a livello trasporto. Per settare il protocollo UDP utilizziamo i comandi:

set sorgente [new Agent/UDP]

set destinazione [new Agent/NULL]

Sorgente e destinazione vanno poi collegati tra loro e ai rispettivi nodi come visto in precedenza.

3.0 Classe Node

Abbiamo visto che ns supporta due tipi di nodi: Unicast (un solo mittente e un solo destinatario) e Multicast (un mittente e più destinatari).Adesso vediamo le funzioni messe a disposizione per la gestione dei nodi. Ogni nodo ha un identificatore costituito da un intero che viene incrementato ad ogni nuova istanza. Per accedere a tale identificatore usiamo

$nome_nodo id

Mentre per accedere al suo indirizzo usiamo

$nome_nodo node_addr

I nodi vicini sono indicati da una lista accessibile da

$node neighbors

Un collegamento tra due nodi è rappresentato da un link. Esso è costituito da cinque elemneti principali:

head_ rappresenta il punto di ingresso del nodo

queue_ rappresenta la coda principale del link

link_ l'oggetto che modella il link

ttl_ oggetto che gestisce il ttl dei pacchetti

drophead_ oggetto che gestisce lo scarto dei pacchetti

Altri oggetti gestiscono il tracciamento dei pacchetti

enqT_ traccia i pacchetti in ingresso

deqT_ traccia i pacchetti in uscita

drpT_ traccia i pacchetti scartati

rcvT_ traccia i pacchetti ricevuti dal nodo successivo

La creazione di un link (la abbiamo già vista) viene effettuata tramite il comando

$nome_simul type-link node1 node2 bw delay qtype args

dove qtype può assumere i valori:

DropTail per la coda FIFO

FQ per il fair queuing

SFQ per la stochastic fair queuing

DRR per la deficit round robin queue

RED per la random early detection queue

CBQ per la class-based queuing

CBQ/WRR per la weighted round robin CBQ

E' possibile definire la dimensione massima della coda con

$nome_simul queue_limit _node1_ _node2_ _limit_

e il ritardo di propagazione nella direzione indicata (rappresentato da timeinterval) con:

$nome_simul delay node1 node2 timeinterval

Alcuni metodi permettono di gestire lo stato del link:

$nome_simul rtmodel-at time command node1 node2

dove command può essere:

up per attivare un collegamento

down per disabilitare un collegamento

up? per interrogare lo stato del link

cost per settare il costo

cost? Per interrogare il costo di un link

4.0 Classi Agent, Application, Traffic Generator

Un agente è un elemento che genera il traffico dati (trasmettitore), rimuove il traffico ricevuto (ricevitore) o fa entrambe le cose (bidirezionale). In realtà non si opera con dati reali ma solo con le dimensioni delle informazioni al fine di tenere traccia della quantità di dati trasmessi. Esistono numerosi tipi di agenti, ciascuno configurabile manualmente. Consultate il manuale ns per avere informazioni dettagliate sui protocolli. La classe Application permette di definire il modello di applicazione al quale associare un profilo di traffico definito dalla classe TrafficGenerator. Esistono 4 classi derivate da TrafficGenerator, ciascuna rappresentante un modello di traffico differente:

EXPOO_TRAFFIC : per il modello di traffico “On/Off” con distribuzione esponenziali dei tempi di permanenza in ogni stato

POO_Traffic: per il modello con tempi di permanenza in ciascuno stato distribuiti secondo una distribuzione di Pareto .

CBR_Traffic: per il modello di traffico a rate costante, con pacchetti di dimensione fissa

TrafficTrace:per il modello di traffico basato su misurazioni reali importate da un trace file).

5.0 Raccolta dei Risultati

Si può ricorrere a due strategie per raccogliere i risultati della simulazione:

Mediante tracefile. Un trace è un oggetto inserito in un link, che raccoglie tutti gli eventi che coinvolgono i pacchetti trasmessi su di esso. Ogni pacchetto è tracciato mendiante la sua intestazione costituita da:

identificativo univoco

tipo di pacchetto

dimensione del pacchetto

identificativo dell’interfaccia di trasmissione (per il multicast)

identificativo di flusso

nodo sorgente

nodo destinazione

Per utilizzare un tracefile bisogna prima aprirlo in scrittura

$nome_simul nome_trace_file [open nome_file w]

Scrivere su file tutte le informazioni raccolte:

$nome_simul trace-queue $node1 $node2 $nome_trace_file

E infine chiudere il file:

close $nome_trace_file

Le voci scritte su file saranno caratterizzate dai seguenti attributi:

tipo di evento (ricezione, accodamento, trasmissione, scarto)

istante in cui si verifica l’evento

nodo sorgente

nodo destinazione

tipo di pacchetto

dimensione del pacchetto

flag per utilizzi specifici (collegamenti wireless, etc,...)

identificativo di flusso

indirizzo e porta del mittente

indirizzo e porta del destinatario

numero di sequenza

identificativo univoco di pacchetto

E' possibile fare il trace di tutti i pacchetti su tutti i link:

$nome_simul namtrace-all $nome_nam_file

$nome_simul trace-all $nome_trace_file

O su uno specifico link:

$nome_simul trace-queue $node0 $node1 $nome_trace_file

$nome_simul namtrace-queue $n0 $n1 $nome_trace_file

Mediante Monitor: un monitor consente di analizzare alcune variabili del modello:

size_ dimensione della coda in byte

pkts_ numero di pacchetti in coda

parrivals_ numero di pacchetti arrivati

barrivals_ numero di byte arrivati

pdepartures_ numero di pacchetti trasmessi

pdrops_ numero di pacchetti scartati

bdrops_ numero di byte scartati

Download 1

V

2009-12-02T22:31:00.002+01:00

Validator: componente che analizza la struttura grammaticale e sintattica di un testo, costituito da sequenze di tokens, al fine di stabilirne la coerenza con determinati standard linguistici. Appartiene alla famiglia dei parser.

Elementi di Programmazione Dinamica

2009-11-27T17:19:00.003+01:00

Elementi di Programmazione dinamica

Download Parte Prima

Download Parte Seconda

Download Parte Terza

Parte Seconda e Terza inserita il 11/12/09 alle ore 6.35

Tabelle Hash

2009-11-14T18:21:00.007+01:00

introduzione all'hashing

Download

Correzione pag.7 il 16/11/2009 ore 12.51

Correzione pag.2 il 27/11/2009 ore 17.48

B-Tree

2009-11-14T18:21:00.004+01:00

introduzione ai b-alberi

Download

TCL\OTCL (Tool Command Language\Object TCL)

2009-11-01T23:04:00.025+01:00

1.0 Fondamenti

Tcl/Otcl è un linguaggio di scripting position-based, solitamente usato su sistemi embedded costituito da una sequenza di comandi separati dal carattere “newline” o ; . Ogni comando è composto da una o più parole che rappresentano la direttiva e i parametri presi in input. Ogni comando genera un suo output costituito da una stringa stampata a video. A differenza di molti linguaggi di scripting il Parser non assegna significati agli argomenti. Ad esempio il comando

% set y 4

Assegna alla variabile y il valore 4

% set x y+5

Assegna alla variabile x il valore stringa “y+5”

%set w $y+10

Assegna alla variabile w il valore stringa “4+10”. Il simbolo $ permette di accedere alla variabile memorizzata con il nome indicato subito dopo il carattere stesso.
Per effettuare le operazioni aritmetiche si ricorre al comando

%expr espressione

Dove espressione rappresenta l’espressione aritmetica che vogliamo calcolare. Il nome di una variabile può contenere lettere , numeri e underscore. Non è necessario definire variabili prima del loro uso. Con la sintassi [ comando ] è possibile inserire comandi come parametri di altri comandi. Ad esempio

%set x [ set y 10]

Assegnerà ad x ed a y il valore 10. In alternativa si può usare “ ”.

%set b 5
%set x “ b-5 vale [ expr $b-5] ”

Ora x varrà “b-5 vale 0”.
I caratteri speciali come $ possono essere ignorati se preceduti dal caratter \ . Ad esempio

%set x \$

Assegnerà ad x il valore stringa $ . Può anche permettere di scrivere un comando su più linee ignorando il carattere “invio”.
Il comando puts permette la scrittura su un determinato device. Per stampare su schermo scriviamo

%puts “ Esempio di stampa su schermo”

I commenti vanno preceduti dal carattere #
Adesso lavoriamo con le stringhe. Possiamo utilizzare i tradizionali caratteri speciali

* zero o più caratteri
? un singolo carattere
[ x-y] un carattere del set compreso dalle lettere qui indicate come x e y
[ ] un set tra i caratteri presenti all’interno delle parentesi.

Le stringhe possono essere manipolate mediante il comando

%String option ?args? ?args?

Vediamo alcune opzioni.

%string first pattern stringa2 ?start_index?

Cerca pattern in stringa2 a partire da start_index se specificato. Ritorna la posizione della prima occorrenza trovata, altrimenti ritorna -1. Possiamo usare l’opzione last al posto di first per avviare la ricerca a partire dall’ultimo carattere.

%string length stringa

ritorna il numero di caratteri presenti in stringa.

%stringa match ?-nocase? pattern stringa

verifica se pattern corrisponde a stringa, altrimenti ritorna -1. Con –nocase è possibile il match è case-unsensitive.

%string range stringa inizio fine

ritorna il range di caratteri trovati in stringa a partire dal pattern inizio e a finire con il pattern fine.

%string tolower stringa ?first? ?last?

ritorna la conversione in minuscolo di stringa a partire da first e a finire con last se questi sono specificati. Al posto di tolower si può specificare toupper per convertire in maiuscolo.

%scan string_format var_name ?var_name2?....

Effettua il parsing dei parametri indicati come var_name secondo la convenzione specificata da string_format. Ad esempio si può usare

%d per intero decimale
%o per intero ottale
%x per intero esadecimale
%b per intero binario
%c per singolo carattere

%format format_string ?arg1? ?arg2?...

Formatta arg1,arg2…. Second la convenzione specificata da format_string
Per ulteriori comandi potete consultare il manuale.

2.0 Liste e Array

Adesso vediamo come usare le liste. In tcl gli elementi di una lista vanno racchiusi tra {}. È possibile annidare più liste per creare matrici. Per creare una lista useremo il comando

%set nome_lista { elemento1 elemento2 ….}

mentre con il comando

%list nome_lista { elemento1 elemento2 ….}

si ottiene la stampa a video della lista ma non viene memorizzata.
Il primo elemento di una lista viene indicato con l’indice 0 mentre l’ultimo con l’indice end. Il comando

%lindex nome_lista ?indice?

restituisce l’elemento di indice ‘indice’ se specificato, altrimenti restituisce tutta la lista. Possiamo ordinare alfabeticamente una lista con il comando

%lsort nome_lista

Il comando supporta diverse opzioni.
Il comando

%lappend nome_lista elemento

inserisce ‘elemento’ alla fine della lista. In questo comando non va specificato il simbolo $ quando ci si riferisce ad una lista memorizzata . Ad esempio se creiamo la lista chiamata elenco e vogliamo inserire l’elemento ‘ultimo’ useremo

%lappend elenco ultimo

E non %lappend $elenco ultimo

Possiamo inserire un elemento nella posizione desiderata con il comando

%linsert nome_lista posizione elemento

Per sapere quanti elementi contiene una lista impartiamo

%llength nome_lista

Passiamo ora agli array. In tcl gli array sono associativi. Ciò vuol dire che l’indice è una stringa che possiamo scegliere a nostro piacere. Per creare una lista o per inserire un elemento usiamo il comando

%set array nome_array(indice) valore

Possiamo creare un array a partire da una lista con il comando

%set array nome_array [ list indice1 elemento1 indice2 elemento2 …]

Possiamo ottenere l’insieme delle coppie indice-valore con il comando

%array get nome_array

Qui non bisogna specificare $.Non otteniamo gli indici ordinati alfabeticamente ne secondo l’ordine di inserimento, ma secondo uno schema utilizzato da tcl per memorizzare la struttura dati. Per ottenere una lista di indici a partire da un pattern specifico usiamo

%array names nome_array ?pattern?

Se pattern non è specificato ritorna tutti i valori. Anche qui non va utilizzato il $.

3.0 Strutture di Controllo

Le strutture di controllo non differiscono molto dagli altri linguaggi. Qui però è importante rispettare la spaziatura tra un carattere e l’altro. Per maggiore chiarezza guardare gli esempi allegati.
Per la selezione:

if {espressione} {
body
} elseif {condizione} {
body
} else {
body
}

Per switch:

Switch ?option? string {
pattern1 body1
…..
}

Per while:

while {espressione} {
body
}

Per for:

for {variabile} {condizione} {cond_progr} {
body
}

Per foreach

foreach variabile { elem1 elem2 … } {
body
}

4.0 I/O su file

Adesso occupiamoci di I/O su file. I file possono essere acceduti mediante una variabile.

Per aprire un file impartiamo

%open nome_var [ open "nome_file" "mod"]

dove mod indica la modalità di accesso e può essere:

w+ per lettura e scrittura, crea il file se non esiste

r+ per lettura e scrittura, il file deve esistere

r per lettura

w per scrittura

Per scrivere un file usiamo il comando puts con parametro la nostra variabile.

%puts nome_var stringa

Chiudiamo il file con il comando

%close nome_var

Per leggere una riga usiamo il comando gets:

%gets nome_var

Per leggere byte usiamo il comando read

%read nome_var n

Dove n è il numero di byte che vogliamo leggere. La scrittura e la lettura verrà effettuata nella posizione in cui si trova il puntatore al file. Per muovere il puntatore nella posizione 'n' usiamo il comando:

%seek nome_var n

Per conoscere l'attuale posizione del puntatore invece diamo:

%tell nome_var

5.0 Procedure

In tcl le procedure possono essere definite per accettare un numero predefinito di elementi oppure un numero variabile. Inoltre possono essere richiamate ricorsivamente, possono ritornare valori o essere "void". Si definisce una procedura mediante la sintassi

proc nome_procedura args1... {

body

}

Se si decide di accettare un numero variabile di parametri, quando la procedura sarà invoca bisognerà racchiudere tutti i parametri tra " " oppure passarli come lista altrimenti l'interprete non sarà in grado di riconoscerli. Una procedura può anche accedere a variabile globali ma queste vanno prima definite prima della procedura, e poi bisognerà indicare all'interprete di cercare quella variabile fuori dalla procedura definita mediante il comando "%global var_name". Se ad esempio vogliamo usare la variabile globale "ciao" nella procedura "saluti" dobbiamo scrivere:

%set ciao ciao

%proc saluti tuo_nome {

global ciao

puts "$ciao $tuo_nome"

}

6.0 OTCL

Otcl è l’estensione ad oggetti di TCL. Anche se si parla di programmazione ad oggetti, OTCL non va pensato come un normale linguaggio Object Oriented come java o C++. In OTCL le classi possono essere definite in maniera incrementale, ovvero i metodi possono essere aggiunti in runtime. Ogni oggetto è un comando, ogni sottocomando è un argomento dell’oggetto. Possiamo definire una classe con il comando

%Class Nome_classe

e un oggetto con il comando

%Nome_classe nome_oggetto

Tutti le variabili e i metodo sono pubblici e tutte le classi ereditano dalla superclasse Object. Questa superclasse fornisce alcuni metodo per reperire informazioni sulle classi o sugli oggetti. Un oggetto può essere distrutto con il comando

%nome_oggetto destroy

Una variabile di un oggetto può essere instanziata con il comando

%nome_oggetto set nome_variabile valore

Se non specifichiamo il valore il comando fornità come risultato il valore attuale della variabile.
Una variabile di classe può essere instanziata con il comando

%nome_classe set nome_variabile valore

e può essere richiamata all'interno delle procedure mediante il comando

%class instvar nome_variabile

Da questo momento in poi, all'interno della procedura, la variabile di classe sarà disponibile.
Possiamo aggiungere un metodo ad una classe con il comando

%nome_classe instproc nome_metodo args1…. {
body
}

I metodi possono essere richiamati con il comando:

%nome_oggetto nome_metodo ?args?

La parola chiave $self può essere utilizzata per riferirsi all’interno di un metodo all’attuale oggetto instanziato . Il comando

%$self instvar nome_variabile

Permette di accedere alla variabile definita da qualche parte all’interno della classe grazie al comando 'instavar'. Un metodo particolare è il costruttore. Serve all’interprete per poter richiamare il costruttore di Object. Se non viene definito dal programmatore verrà implementato dall’interprete. Un metodo costruttore ha la forma:

%nome_classe instproc init {args} {
……body….
eval $self next $args
}

L’ultimo rigo di comando permette all’interprete di richiamare il costruttore della superclasse.
Otcl ammette l'ereditarietà multipla. Per per ereditare da una serie di classi usiamo:

%Class nome_classe -superclass {nome_superclasse1 nome_superclasse2....}

Nel caso in cui le superclassi implementassero metodi con stess prototipo e firma, uno soltanto dei metodi verrà ereditato. Sarà l'ordine con cui sono indicate le superclassi a stabilire quale sarà il metodo ereditato. Le classe indicata per prima avrà priorità maggiore rispetto alle successive. E' possibile scrivere classi in file script diversi. Basta scrivere il codice su file, ad esempio, un file per ogni classe, scrivere il "main" su di un file aggiungendo come primissime istruzioni i comandi

%source nome_script

uno per ogni file che abbiamo scritto. Il "main" sarà l'unico file che dovremmo eseguire direttamente.

Download1

Download2

Archivio Download1 aggiornato il 07/11/2009 alle 14.15

Archivio Download2 inserito il 10/11/2009 alle 19.55

Correzione post il 12/11/2009 alle 12.26

Correzione Download2 il 05/12/2009 alle 18.33

K

2009-08-24T10:18:00.002+02:00

Known Iusses: insieme di problemi noti agli sviluppatori, posti all'attenzione degli utenti. Tali problemi possono rappresentare bugs non ancora risolti oppure emergono in corrispondenza di cattivi utilizzi da parte degli utenti o in presenza di software con problemi di compatibilità.

G

2009-08-24T10:15:00.002+02:00

Good Practise: Insieme di buone norme da tenere in considerazione quando si programma in un determinato linguaggio o quando si utilizza un determinato software.

Grid Computing: infrastruttura informatica costituita da numerosi calcolatori distribuiti, distanti geograficamente, basata sulla condivisione organizzata delle risorse hardware, al fine di risolvere un problema comune all'intera struttura.

Fondamenti di HTML parte terza

2009-08-10T22:01:00.001+02:00

Terza e ultima parte di fondamenti di html.

Download

Fondamenti di HTML parte seconda

2009-08-04T16:11:00.002+02:00

Seconda parte di fondamenti del linguaggio HTML (4.0)

Download

Fondamenti di HTML parte prima

2009-08-02T11:45:00.001+02:00

Prima parte di fondamenti del linguaggio html ( v4.0).

Download

VIM Editor

2009-06-27T21:48:00.003+02:00

Questo post riassume le principali funzioni del famoso editor VIM. VIM si basa su due modalità di funzionamento, una a "comandi" e una ad "inserimento". Con la prima modalità è possibile inviare comandi di gestione del programma, con la seconda è possibile modificare il file.All'avvio viene sempre eseguita la modalitàa comandi, per passare a quella ad inserimento premiamo 'i'. Per tornare al prompt dei comandi premiamo ESC. Occupiamoci dei comandi principali. In modalità comandi, inseriamo un comando preceduto dal simbolo ":" e seguito dalla pressione del tasto enter. I comandi preceduti da : sono comandi di fine riga,praticamente quelli che troverete nel 'menù file' di un moderno editor, tutti gli altri ci permettono di operare con il testo.Ad esempio impartiamo

:w per salvare le modifiche al file o:w nome_file se abbiamo aperto un nuovo file e vogliamo salvarlo.

:q per abbandonare la sessione di VIM.

I comandi possono anche essere concatenati. Ad esempio con

:wq nome_file salviamo ed usciamo dalla sessione di VIM.

:q! usciamo senza salvare le modifiche o il file.

Per operare con il testo useremo i seguenti comandi.Ad esempio:

w per spostare il cursore sul primo carattere della parola successiva.

b per spostarci sul primo carattere della parola precedente.

e per spostarci sull'ultimo carattere della parola successiva.

ge per spostarci sull'ultimo carattere della parola precedente.

$ per spostarci alla fine della riga.

^ per spostarci sul primo carattere (non di spaziatura) della riga.

0 per spostarci all'inizio della riga.

G per spostarci alla fine del documento.

gg per spostarci all'inizio del documento.

zz per centrare la schermata sulla riga dove è situato il cursore.

zt per far diventare la riga dove è situato il cursore la prima riga della schermata.

zb per far diventare la riga dove è situato il cursore l'ultima riga della schermata.

Per marcare una riga in modo da poterci tornare rapidamente usiamo il comando

mx dove x rappresenta una lettera.Per tornare su quella riga basterà usare il comando

'x dove x rappresenta la lettera marcatrice.

Il comando di fine riga

:marks mostra tutte le righe marcate con i rispettivi marcatori. I comandi

Ctrl+b e Ctrl+f si usano come i comandi page-up e page-down.

Ctrl+u e Ctrl+d compiono le stesse operazioni ma con metà schermata.

Il comando % permette di raggiungere, se il cursore è situato su una parentesi aperta o chiusa, la rispettiva parentesi chiusa o aperta. Altri comandi per l'editing sono

a passa alla modalità inserimento dopo aver spostato il cursore a destra dell'ultimo carattere sulla stessa riga.

I passa alla modalità inserimento dopo aver spostato il cursore a inizio riga.

o passa alla modalità inserimento dopo aver aggiunto una riga sotto il cursore .

O come o ma sulla riga sopra il cursore.

x cancella il carattere su cui si trova il cursore.

X cancella il carattere a sinistra del cursore.

dw per cancellare una paroladd per cancellare una intera riga.

D cancella tutto quello che segue il cursore fino alla fine della riga.

c(seguito da spazio) come d ma passa alla modalità inserimento.

cc(seguito da spazio) come dd ma passa alla modalità inserimento.

C(seguito da spazio) come D ma passa alla modalità inserimento.

u effettua un "undo".

CTRL+r effettua l'annullamento di un "undo".

. effettua un "redo".

Per cercare una stringa impartiamo

/stringa_da_cercare per cercare avanti nel testo.

?stringa_da_cercare per cercare indietro nel testo.

Per sostituire una stringa str con un'altra str2 impartiamo.

:s/str/str2 per sostituire una sola occorrenza.

:s/str/str2/g per sostiture tutte le occorrenze.

Configurazione delle Reti

2009-06-26T14:22:00.037+02:00

1.0 Configurare le reti

In questo post vedremo come configurare reti tra macchine GNU-Linux. Utilizzeremo per semplicità macchine virtuali la cui installazione è stata vista in un post precedente. Partiremo da un semplice esempio per poi vederne di più complessi. Cominciamo dalla figura sotto:

Ci viene mostrata una semplice rete locale tra quattro macchine che potranno comunicare tra loro. Dalle impostazioni di una delle quattro macchine virtuali selezioniamo "Rete", e nel menù relativo alla voce "Connessa a" selezioniamo "Rete Interna" e diamo il nome lan0. Per le macchine rimanenti effettuiamo la stessa operazione e colleghiamole alla stessa rete lan0. A questo punto ci basta avviare tutte le quattro macchine, e in ciascuna di essa impartiamo il comando ifconfig eth0 xxx.xxx.xxx.y , dove eth0 indica la prima schede di rete, (eth1 la seconda e così via) e xxx.xxx.xxx.y indica l'indirizzo ip. Affichè le macchine possano comunicare devono appartenere alla stessa rete. Ad esempio se vogliamo che la nostra rete abbia indirizzo 192.168.10.0 impartiamo i seguenti comandi, uno per ogni macchina.

macchina1 -> ifconfig eth0 192.168.10.1/24

macchina2-> ifconfig eth0 192.168.10.2/24

macchina3-> ifconfig eth0 192.168.10.3/24

macchina4->ifconfig eth0 192.168.10.4/24

Con il comando ping xxx.xxx.xxxx.y controlliamo se la rete sta in effetti funzionando. Memorizziamo le modifiche effettuate agli indirizzi IP delle macchine modificando per ciascuna di esse il file di configurazione /etc/rc.d/rc.inet1.conf e inserendo l'indirizzo nella relativa scheda di rete. Adesso passiamo a qualcosina di più complicato. Guardiamo lo schema in basso

La figura ci mostra due host connessi tra loro attraverso un gateway (anche questo è un macchina virtuale slackware). In questo caso dobbiamo configurare diversamente le schede di rete. Aggiungiamo per la macchina a sinistra una scheda di rete connessa ad una lan interna che chiamiamo lan0. Per la macchina a destra aggiungiamo una schede di rete connessa ad una lan interna che chiamiamo lan1. La macchina al centro avrà ben due schede di rete, la prima (eth0) connessa alla lan0, e la seconda (eth1) connessa alla lan1. E' importante tenere a mente l'ordine delle schede se non vogliamo fare pasticci. A volte le macchine possono rinominare le schede di rete. Cancelliamo il file /etc/udev/rules.d/70-persistent-net.rules e riavviamo per risolvere. Adesso passiamo agli indirizzi IP. Assegniamo alla macchina a sinistra 192.168.10.2/24, al gateway sul dispositivo eth0 192.168.10.1/24 e su eth1 192.168.11.1/24, mentre alla macchina a destra assegnamo l'indirizzo 192.168.11.2/24. Come al solito se tutto è stato configurato per bene, dovremmo pingare il gateway sia dalla macchina a sinistra che da quella a destra. Adesso dobbiamo inserire le nuove regole di routing statico. Per prima cosa assicuriamoci che l'ip fowarding sia abilitato.Posizioniamoci sul gateway ed impartiamo i comandi

chmod +x /etc/rc.d/rc.ip_forward

e riavviamo il servizio con

/etc/rc.d/rc.ip_forward restart

Siamo già a buon punto. Noi vogliamo che la macchina 192.168.10.2 veda la macchina 192.168.11.2 e viceversa. Nella prima macchina impartiamo il comando

route add -net 192.168.11.0/24 gw 192.168.10.1

mentre nella seconda impartiamo

route add -net 192.168.10/24 gw 192.168.11.1

Con il primo comando stiamo semplicemente dicendo di dirottare tutti i pacchetti destinati alla rete 192.168.11.0 al gateway di indirizzo 192.168.10.1. Con il secondo comando facciamo la stessa cosa per la seconda rete e il suo gateway.Proviamo a pingare le due macchine per avere conferma del lavoro fatto. Possiamo attribuire ad ogni indirizzo un nome così da non doverli ricordare ogni volta. Modifichiamo il file /etc/hosts aggiugendo voci del tipo:

xxx.xxx.xxx.xxx nome_host

dove la sequenza di x è l'indirizzo ip dell'host e nome_host è il suo nome. Possiamo richiamare così la macchina ricorrendo ad un nome ASCII piuttosto che al suo indirizzo IP. Le tabelle di route non vengono mantenute al riavvio della macchina. Ovviamo al problema modificando il file di script /etc/rc.d/rc.local aggiungendo alla fine di esso gli stessi comandi così come li abbiamo visti (ricordate la sintassi di bash), oppure creando un apposito file di script e collegandolo a rc.local mediante il comando "source " seguito dal pathname del nostro script. Adesso estendiamo la figura precedente collegando il gateway ad internet come mostrato sotto.

Per raggiungere la configurazione desiderata basta poco. Aggiungiamo una terza scheda di rete (ad esempio eth3) al gateway collegata in NAT ed avviamo la macchina. Possiamo configurare manualmente la terza scheda di rete e per farlo dobbiamo consultare la guida di virtual box per sapere gli indirizzi di dns,gateway e ip della scheda. Otteniamo questi valori direttamente dalla nostra macchina eseguendo il comando

dhcpcd eth3

e attendiamo che termini. Per far sì che le altre due macchine possano collegarsi a internet diciamo loro di usare come gateway predefinito proprio il nostro gateway al centro della figura.Impartiamo il comando

route add default gw 192.168.10.1

per la macchina a destra e

route add default gw 192.168.11.1

per quella a destra. Fatto ciò proviamo a pingare un server remoto.Possiamo salvare la nostra configurazione modificando il file /etc/rc.d/rc.inet1.conf . Se vogliamo ottenere il servizio dhcp all'avvio del sistema, modifichiamo la voce " Use DHCP " della relativa scheda di rete in questo modo:

USE_DHCP[x]="yes"

dove x rappresenta il numero della scheda di rete. Per il gateway predefinito modifichiamo la voce

GATEWAY="xxx.xxx.xxx.xxx"

dove la sequenza di x rappresenta l'indirizzo ip. A volte potremmo desiderare di configurare un collegamento ad internet statico. La procedura è identica a quella vista fino ad ora, dobbiamo solo conoscere gli indirizzi corretti da assegnare al gateway e al dispositivo. Potete trovarli nel paragrafo 9.12 della guida di VirtualBox. Le tre tipologie che abbiamo appena visto rappresentano praticamente le basi per realizzare qualsiasi rete. Le prossime che vedremo saranno topologie un pò più complicate. Non spiegherò tutti i passi necessari a configurare le reti dato che li abbiamo già visti ma affronterò il "modus operandi" di affrontare il problema di una configurazione complessa. Concentriamoci sulla figura in basso.

In questo vi sono due gateway che connetto tra loro e ad internet 5 postazioni. L'approccio utilizzato fino ad ora non è più adatto a queste topologie. Innanzitutto perchè potremmo fare confusione facilmente, inoltre se la rete fosse reale e non virtuale dovremmo spostarci in continuazione tra le varie macchine distanti geograficamente, a volte, per chilometri. Noi dobbiamo ottimizzare la risorsa "fatica" e la risorsa "tempo". Procuriamoci dunque un foglio di carta e ricopiamo lo schema (o stampiamo la figura). Indichiamo tutti i dispositivi di rete affiancati dall'indirizzo ip che abbiamo scelto. Nel caso delle macchine virtuali indichiamo anche il nome della rete interna che abbiamo deciso evitando così di fare confusione. L'approccio migliore in questi casi è quello "top-down". Ricordiamo che dovremmo spostarci su ogni macchina al massimo due volte, una per la configurazione e un'altra, eventualmente, per il test finale. Iniziamo con la macchina collegata ad internet. Configuriamo gli indirizzi ip delle schede e l'accesso alla rete. Aggiungiamo le voci di route che permetteranno di raggiungere le tre macchine collegate al secondo gateway attraverso quest'ultimo. Ricordiamoci le modifiche al file rc.ip_forward. Adesso configuriamo le due macchine collegate al primo gateway, procedendo sempre prima con gli indirizzi di rete e poi con le voci di route per raggiungere le altre macchine collegate al secondo gateway e ad internet. Adesso tocca al secondo router. Sempre gli ip per prima, poi le voci di router per il collegamento ad internet e alle due macchine collegate al primo gateway. Infine i tre pc collegati al secondo gateway. Gli indirizzi ip per primo, il primo gateway e le due macchine a lui collegate,internet, e le rimanenti macchine al secondo gateway. Adesso, a ritroso, posizioniamoci sulle varie macchine per la fase di test. Ricordiamo di pingare tutte le altre macchine per l'assoluta certezza del successo dell'impresa. Ogni topologia di rete può richiedere un approccio diverso. Anche se dovremmo comunque dirigerci su ogni macchina potrebbe essere conveniente per fini logistici partire da alcune macchine piuttosto che da altre. La figura che segue prevede quattro gateway collegati tra loro, ciascuno di essi collegati con una propria macchina.

Dato l'alto numero di gateway, potremmo partire proprio da questi per configurare la rete, e poi successivamente configurare gli host. La figura in basso è un'altro esempio. Stavolta lascio scegliere a voi il punto da cui partire.

Potrebbe essere necessario dover collegare più schede di rete ad un host. L'interfaccia di virtual box permette di collegare fino a 4 dispositivi, gli altri dovremmo aggiungerli dalla console. Utilizziamo in sequenza i comandi

vboxmanage modifyvm [nome_macchina] -nic[num_dispositivo] [tipo_dispositivo]

I parametri sono racchiusi tra []. Il primo rappresenta il nome della macchina alla quale vogliamo aggiungere i dispositivi. Il secondo, [num_dispositivo] rappresenta il numero della scheda di rete ( praticamente da 5 in poi ), l'ultimo indica il tipo di rete, ad esempio "intnet" per la rete interna, "natnet" per la rete NAT ecc. Il secondo comando è:

vboxmanage modifyvm [nome_macchina] -[tipo_dispositivo][num_dispositivo] [nome_rete]

I primi tre parametri sono gli stessi del primo comando, l'ultimo invece rappresenta il nome da dare alla rete, ad esempio per una rete interna , il nome della lan interna. Il secondo e il terzo parametro NON devono essere separati da spazio, ad esempio se colleghiamo il quinto dispositivo di rete ad un rete interna chiamata lan5 nella macchina chiamata A scriveremo in questo modo i due comandi:

vboxmanage modifyvm A -nic5 intnet

vboxmanage modifyvm A -intnet5 lan5

vboxmanage modifyvm

Chiariamo una cosa circa l'uso della fascia di indirizzi 192.168.0.0/16 usata negli esempi. Questa fascia di indirizzi viene utilizzata come fascia standard di classe C per le reti private. Una rete privata è una rete non indirizzabile dall'esterno, quindi avente validità solo per l'interno (ovvero dietro il router) e pertanto non visibile dall'esterno.Naturalmente questo indica che nel mondo possono esistere tante reti private con le stesso indirizzo. Di fatto, quando si acquista un comune router ADSL l'indirizzo default dell'interfaccia interna del dispositivo sarà 192.168.1.1/16. Il documento RFC 1918: Address Allocation for Private Internets indica quali sono le fascie di indirizzi utilizzati per le reti private. Esse sono:

da 10.0.0.0/8 a 10.255.255.255/8 di classe A
da 172.16.0.0/12 a 172.31.255.255 di classe B

da 192.168.0.0/16 a 192.168.255.255/16 di classe C

2.0 Assegnare indirizzi ip e sottoreti

Fino ad ora abbiamo assegnato indirizzi ip in modo innaturale. Vediamo adesso come assegnare indirizzi ip e sottoreti quando un provider ci assegna una fascia di indirizzi. Supponiamo di ricevere l'indirizzo di classe B 142.154.0.0/16. Abbiamo a disposizione 2^(32-16)-2 indirizzi cioè 65534. L'azienda per cui lavoriamo ci chiede di realizzare inizialmente 3 sottoreti da 5000 ,5000 e 1000 indirizzi. Una rete da 5000 indirizzi richiede almeno 13 bit per indirizzare tutti gli host. In forma binaria cioè vuol dire

xxxxxxxx xxxxxxxx yyy-00000 00000000

dove la sequenza di x indicano i bit relativi all'indirizzo di rete , la sequenza di y quelli relativi al prefisso univoco di sottorete, gli zeri sono quelli dedicati agli hosts. In questo modo noi otteniamo 8 sottoreti da 2^13 hosts. Ad asempio il prefisso 111 possiamo usarlo per indirizzare una sottorete da 5000 host. Se traduciamo gli indirizzi in formato decimale otteniamo 142.154.224.0./19 .Gli indirizzi da assegnare agli hosts vanno dunque da 142.154.224.1 a 142.154.255.254. Il prefisso 110 lo usiamo per la seconda sottorete da 5000. In questo caso otteniamo l'indirizzo 142.154.192.0/19 cioè la fascia di indirizzi da 142.154.192.1 a 142.154.223.254 . Resta la sottorete da 1000 e la backbone. Prendiamo il prefisso 100 cioè la fascia di indirizzi da 142.154.128.1 a 142.154.159.254. Dividiamo in altre 8 sottoreti da 1024 hosts.

xxxxxxxx xxxxxxxx 100-yyy-00 00000000

Prendiamo il prefisso 111 cioè

xxxxxxxx xxxxxxxx 100111-00 00000000

Alle sottorete da 1000 host va dunque l'indirizzo 142.154.156.0/21 cioè da 142.154.156.1 a 142.154.159.254 . Per la backbone e per espansioni future ci servono sottoreti da pochi numeri. Possiamo dividere ulteriormente la sottorete ad esempio in 32 sottoreti da 8 hosts. Ci servono dunque altri 5 bit per la sottorete ad esempio

xxxxxxxx xxxxxxxx 10000000 00000-000

cioè la fascia 142.154.128.0/29 ovvero da 142.154.128.1. a 142.154.128.7.

Qui troverete lo schema della configurazione.

Qui alcuni script per reti.

Confronti tra Notazioni e Alcune equazioni di ricorrenza

2009-06-23T19:35:00.001+02:00

Equazioni di ricorrenza svolte:

Download

Confronti tra Notazioni Asintotiche.

Download

Installazione Slackware su Macchina Virutale

2009-06-15T22:10:00.015+02:00

In questo post vedremo come installare una copia di Slackware su una macchina virutale che potremo utilizzare per effettuare le varie operazioni che vedremo in questo archivio senza intaccare il nostro sistema nativo. Per prima cosa dovremo procurarci una copia di slackware, in questo caso l'immagine dvd, e una copia di VirtualBox reperibile al sito http://www.virtualbox.org/ ( in alternativa possiamo scegliere Virtual MachineWare o Microsoft Virtual PC ma VirtualBox è free). Installiamo il virtualizzatore e apriamo il programma. Selezioniamo la voce "Nuova" e clickiamo su "Avanti". Inseriamo il nome della macchina virtuale ad esempio "slack0", selezioniamo Linux e Linux 2.6 dalle due ComboBox sotto e proseguiamo. Dato che il sistema sarà privo di GUI 128 mega di ram saranno abbondantemente sufficienti, selezioniamo tale quantità nella schermata che ci si presenta e proseguiamo. Creiamo un nuovo disco fisso e passiamo avanti. Consci di quello che stiamo facendo proseguiamo ancora. Selezioniamo "Archiviazione a Dimensione Fissa" dal RadioButton. Se vogliamo spazio a volontà selezioniamo un giga di HD ma a noi ne serviranno molto meno, circa 250 MB. Completiamo la procedura e clickiamo su fine. Il riassunto ci informerà su quanto fatto. Proseguiamo e notiamo la nuova macchina virtuale nel pannello a sinistra. Selezioniamolo e clickiamo su "Impostazioni". Nella nuova finestra ,nel pannello a sinistra selezioniamo "Rete" e assicuriamoci che la prima scheda di rete sia abilitata e collegata in NAT. Selezioniamo poi CD/DVD-ROM, spuntiamo la CheckBox "Monta Lettore DVD", selezioniamo la RadioButton "File Immagine ISO" e clickiamo sul pulsante di esplorazione subito a destra. Clickiamo su "Aggiungi" e selezioniamo l'immagine iso di slackware che abbiamo scaricato. Clicchiamo su "Seleziona", poi su "OK". Clicchiamo su "Avvia" assicurandoci che la macchina 'slack0' sia selezionata. Ecco come si presenta all'avvio.

Premiamo invio e attendiamo il caricamento del kernel, quando ha finito scriviamo '1' e diamo invio in modo da poter scegliere la lingua della tastiera. Selezioniamo con le frecce 'qwerty/it.map' e diamo invio come in figura.

Nella prossima schermata inseriamo '1' e diamo invio. Adessiamo scriviamo "root" e diamo invio. Impartiamo "cfdisk". Ecco come si presenta.

Usando le freccie destra e sinistra ci spostiamo su [New] e diamo invio. Selezioniamo [Primary] e nella schermata successiva inseriamo la dimensione della partizione di swap e diamo invio. Dato che è un sistema di prova ed è in macchina virtuale 20 mega sono più che sufficienti. A questo punto è già selezionata la voce [Beginning] e possiamo dare ancora invio. Ecco la nuova schermata.

Adesso impostiamo la partizione creata come SWAP.Usiamo ancora le frecce laterali per selzionare [TYPE] e diamo invio. Premiamo un tasto qualsiasi come dice la schermata e in quella successiva assicuriamoci che "Enter file system type" abbia valore 82 (altrimenti sciviamolo noi) e diamo invio. Adesso invece usiamo le frecce Su e Giù per spostarci nello spazio non partizionato e dopo usiamo le frecce laterali per spostarci di nuovo su [New] e diamo invio, selezioniamo [Primary] e diamo invio, e ancora invio per selezionare tutto lo spazio rimasto. Ancora usando le frecce laterali spostiamoci su [Write] e diamo invio. Digitiamo "yes" e diamo invio per scrivere la tabella delle partizioni. Quando ha finito spostiamo su [Quit] e diamo invio. Tornati al prompt impartiamo il comando "setup".Ecco cosa ci appare. Selezioniamo "ADDSWAP" e diamo invio.

Il programma di installazione avrà già rilevato la partizione di swap, non ci resta che dare invio. Alla schermata successiva selezioniamo "NO" e diamo invio. Attendiamo la nuova schermata e diamo invio. Nella schermata successiva dovremmo selezionare la partizione di installazione. Il programma la avrà già rilevata, diamo invio. Ora selezioniamo "Format" e diamo invio. Selezioniamo "ext2" o "ext2" a voi la scelta e diamo invio. Attendiamo la nuova schermata e diamo ancora invio. Ora selezioniamo la voce numero 1 e diamo invio. Selezioniamo "auto" e ancora invio. Attendiamo che carichi l'iso. A noi interessa fare una installazione minimale, quindi nella schermata successiva utilizzando le frecce e la barra spaziatrice deselezioniamo tutte le voci tranne A,AP,N che sono le uniche categorie di pacchetti che ci interessano e diamo invio. Nella schermata successiva selezioniamo la voce "expert" e diamo invio. Adesso il programma ci mostrerà tutti i pacchetti contenuti nella categoria a. Diamo un'occhiata al file di testo scaricabile da questo post per sapere cosa selezionare e cosa no. Facciamo la stessa cosa anche con le categorie AP ed N. Selezionati i pacchetti attendiamo l'installazione. Ultimata l'operazione non ci resta che installare LILO e configurare le ultime cose. La schermata successiva all'installazione ci chiederà di creare un pendrive avviabile che a noi non serve quindi selezioniamo "skip" e andiamo avanti. Ora ci si presenta la schermata di installazione di LILO. Selezioniamo "simple" e diamo invio.Nella schermata successiva lasciamo tutto com'è e diamo invio.Stessa cosa per quella successiva e quella ancora dopo. Adesso selezioniamo "MBR" e diamo invio. La schermata successiva ci chiederà di installare il mouse. A noi non serve quindi diamo invio. Diamo invio anche a quella successiva. Adesso installiamo la rete. Selezioniamo "Yes" e diamo invio. Mettiamo come hostnome un nome di nostra fantasia ad esempio "slack0" e diamo invio. Scriviamo "slack0.org" nella successiva schermata e diamo invio. Ora selezioniamo "DHCP" e proseguiamo. Diamo invio alla schermata successiva e a quella dopo. Lasciamo l'autoavvio dei servizi così come è e proseguiamo. Diamo invio alla schermata successiva e a quella che segue selezioniamo "no". La lista che abbiamo davanti ci permette di selezionare l'ora locale. Selezioniamo quindi Europe/Rome e andiamo avanti. Ora impostiamo la nuova password di root se vogliamo a noi non interessa. Abbiamo finito. Confermiamo il termine dell'installazione e usciamo dal setup. Dalla barrà dei menù della macchina virtuale selezioniamo "Dispositivi" e poi "Smonta CD/DVD-ROM. Nel prompt impartiamo il comando "reboot" per riavviare. Al termine del riavvio ci ritroviamo nel bootloader LILO. Diamo invio per avviare Slackware. Terminato il caricamento possiamo autenticarci e iniziare ad usare Slackware. Una cosa che ci tornerà utile sarà clonare la nostra macchina. Infatti potremmo aver bisogno di una rete locale di macchine slackware collegate tra loro. Invece di effettuare altre installazioni, cloniamo quella che abbiamo già fatto. Sia che il virtualizzatore si trovi su un sistema Linux o Windows la procedura è pressocchè identica poichè utilizzeremo la console di VirtualBox. Il comando che utilizzeremo sarà:

VBoxManage clonehd Nome_Disco_Origine.vdi Nome_Disco_Destinazione.vdi

Nel caso precedente se il nome dell'hard disk virtuale che abbiamo creato è slack0 ci basta digitare:

VBoxManage slack0.vdi slack1.vdi

Per avere slack1 come copia esatta di slack0. A questo punto creiamo una nuova macchina virtuale come abbiamo visto in precedenza e selezioniamo l'hard disk virtuale che abbiamo creato. Ricordatevi inoltre di cambiare l'hostname delle varie macchine se non volete problemi con le reti.

Download Elenco Pacchetti

Ubuntu 9.04 primi problemi

2009-05-04T21:17:00.008+02:00

Come ho già ribadito in altri post, di solito non mi occupo di bug di applicazioni e di TipsAndTricks ma lavorando prevalentemente con sistemi GNU-Linux mi sono trovato di fronte alcuni problemi relativi al nuovo upgrade di linux, tra i quali il mancato riconoscimento del controller di rete da parte di NetworkManager. Navigando in rete molti parlano di compilare driver, scaricare pacchetti o addirittura rimuovere NetworkManager. In realtà non si tratta di un problema di compatibilità con la scheda ma di un piccolo bug del programma. Infatti pare che dopo aver configurato la prima connessione pppoe il software si disattivi al primo riavvio. Per ovviare al problema basta digitare:

sudo gedit '/etc/NetworkManager/nm-system-settings.conf'

e sostituire nella voce "managed=false" , false con true e in seguito al riavvio riotterrete il controllo della scheda tramite NetworkManager. Se volete la connessione all'avvio del sistema rimuovete anche il plug-in ifupdown cancellando la parola "ifupdown".

Piccola nota. Il bug sembra essere presente anche nella precedente versione di ubuntu. Lascio comunque il post così come è per annotare il problema.

Confronti tra Equazioni Di Ricorrenza

2009-05-01T11:56:00.004+02:00

Esempi di confronti tra equazioni di ricorrenza.

Download 1

Risoluzione di Ricorrenze con Albero di Ricorsione

2009-05-01T11:48:00.018+02:00

Esempi sulla risoluzione di equazioni di ricorrenza mediante albero di ricorsione.

Download 1

Download 2

Download 3

Il secondo archivio è stato modificato in data 08/05/2009 ore 16.04.
Il terzo archivio è stato aggiunto in data 11/05/2009 ore 13.33
Errata Corrige:
Nel Download 2, nell'equazione 5T(n/3)+n^2 l'altezza dell'albero è log in base 3 di n.
Nel Download 1, è stata sostituita la pagina 1 in data 04/06/2009 ore13.03
Nel Download 1, sono state sostituite le pagine 8,9 in data 05/06/2009 ore 12.21.

Nel Download 1 è stata sostituta la pagina 8. Modifica in data 02/09/10 ore 19.28
Nel Download 3, equazione 2T(n/2)+3T(n/3)+1 , il costo a livello i è 2^i (non 5) di conseguenza il risultato è O(n) ( non O(n^3)) , il resto della dimostrazione è esatto (errore di trascrizione). Inoltre nel disegno dell'albero sostituire n con 1 (poichè il costo di assemblamento è costante)
Nel download 1, nel riquadro in rosso, c'era un errore di segno (un -2n al posto di 2n). L'errore è stato corretto il 28 ottobre 2011.

Gestione dei servizi di rete

2009-03-22T17:42:00.008+01:00

1.0 Demons di base per la gestione dei servizi

Adesso ci occuperemo di come gestire i demoni per i servizi di rete. Il primo demone che analizzeremo sarà inetd. Questo demone ha il compito di avviare demoni client ogni qual volta questi hanno dei compiti da svolgere, e, una volta terminati, li chiude in modo del tutto trasparente. Inetd rimane in ascolto delle porte di rete che normalmente sono gestite dai suoi demoni client e quando si verifica una connessione avvia il demone appropriato. Le impostazioni relative alle porte di rete su cui mettersi in ascolto si trovano nel file inetd.conf. Un rigo di questo file ha una struttura del tipo:

service type protocol wait user[.group] server cmdline

dove service rappresenta il servizio. L’associazione porta- servizio si trova sul file /etc/services. Il campo type rappresenta il tipo di socket (stream o dgram), protocol il protocollo che deve essere presente nel file /etc/protocols; il quarto campo che può assumere il valore wait o nowait. Se è impostato a wait inetd non genererà una nuova copia del demone ad ogni richiesta, se è impostato a nowait lo farà. Il campo user rappresenta l’utente ed eventualmente il gruppo sotto il quale avviare il demone. I campi rimanenti rappresentano i nomi qualificati del demone e i suoi argomenti di linea di comando. Il demone TCO wrapper ha tra i suoi compiti quello di tenere traccia dei tentativi di connessione e di restringere l’accesso a seconda del servizio a cui si vuole accedere. Gli accessi ai servizi vengono impostati mediante i file /etc/host.allow e /etc/host.deny . Se nei file non ci sono corrispondenze viene consentito l’accesso. Una riga del file ha una struttura del tipo

daemon_list : client_list [ : shell_command ]

dove il primo campo rappresenta una lista di servizi ( si può impostare ALL per indicare tutti i servizi), il secondo campo rappresenta la lista dei client a cui il servizio è negato (nel file host.deny ) o consentito (nel file host.allow), l’ultimo campo rappresenta il comando da eseguire quando viene verificata la corrispondenza. Il campo client_list può essere specificato in diversi modi:

indirizzo_ipv4/netmask_ipv4 per la rappresentazione classica
indirizzo_ipv4. per gli ip o domini che iniziano con il prefisso specificato
.indirizzo_ipv4 per gli ip o domini che terminano con il suffisso specificato
ALL per indicare tutti gli ip
LOCAL per indicare gli indirizzi locali
PARANOID per indicare il nome che non corrisponde all'ip
KNOWN/UNKNOW per indicare un host con nome conosciuto o sconosciuto
EXCEPT utilizzato con un elenco di nomi per indicare gli host da escludere dalla condizione specificata

Funzioni analoghe a TCP wrapper sono svolte da tcpd. Questo demone si integra con inetd e funge da wrapper per tutti i servizi avviati da inetd. Xinetd è stato di recente sostituito da inetd ma è ancora presente in molte distribuzioni. Il suo file di configurazione è /etc/xinetd.conf, e contiene per ogni servizio una sezione del tipo

service nomeservizio

{
...
attributo =+=-= valore
...
}

Gli attributi sono socket_type, protocol,wait, user, group, type, server, server_args con funzioni identiche a quelle viste per inetd. Si può inoltre specificare

id riferito da host.allow e host.deny per i servizi che appaiono in più sezioni per protocolli differenti.
disable per abilitare o disabilitare il servizio.
only_from, no_access per restringere o vietare l'accesso a determinati ip
access_time indica l’ orario in cui è consentito l'accesso.
log_type indica dove effettuare il log, su file o con syslog
log_on_success, log_on_failure indica le informazioni da includere nei log in caso si successo o fallimento.

Il demone portmap si occupa,invece, della gestione dei servizi basati su RPC contenuti nel file /etc/RPC. NFS è il demone che si occupa dell’esportazione dei file su computer remoti. Richiede portmap per il suo utilizzo, è efficace ed utilizzato in quasi tutti i sistemi Unix ma non prevede nessuna forma di autentificazione ( quindi si basa sul buon senso della progettazione della rete). Dal lato server, nfs richiede l’attivazione di alcuni demoni ma in molte distribuzioni ciò avviene in automatico. Questi demoni sono:

rpc.mountd (gestione montaggio lato server)
rpc.nfsd (funzionalità userlevel, si agganciano al
modulo del kernel).
rpc.lockd e rpc.statd (legati alla gestione dei lock)
rpc.rquotad (gestione quota su nfs)

Il file di configurazione è /etc/exports e contiene le informazioni sui file da esportare. La sua configurazione, molto intuitiva, è

cartella_di_partenza [nodo] [(opzioni)]...

Alcune opzioni sono:

ro (predefinita),
rw (modalità di accesso);
root_squash: (tutti gli accessi come root al file system condiviso vengono trasformati in accessi di nobody)
no_root_squash (funzione inversa a root_squash)

Anche l’utilizzo è molto semplice, mediante il comando exsportfs e i parametri

-a per esportare tutto.
-u per disattivare l’esportazione delle cartelle indicate di seguito
-r per riesportare tutto.

Il lato client richiede solamente che il kernel supporti il file system, e il montaggio avviene tramite il comando

$mount [opzioni] nodo_remoto:cartella_remota

Opzioni particolari permettono di impostare timeout e dimensione dei pacchetti.

2.0 Demoni avanzati per la gestione dei servizi

Il primo demone di cui ci occuperemo in questo paragrafo sarà sshd (Secure Shell Daemon). In pratica è l’evoluzione del servizio telnet, si occupa di consentire l’accesso ad una shell remota, mediante la trasmissione di dati cifrati. I file di configurazione del client e del server si trovano in
/etc/ssh/ (globali) ed in $HOME/.ssh/ . Le chiavi pubbliche per l’autentificazione con passphrase si devono aggiungere nel proprio file ~/.ssh/authorized_keys. La chiave pubblica del server si aggiunge nel file ~/.ssh/known_hosts. Troveremo il file di configurazione di sshd in /etc/ssh/sshd_config. Tra le tanti opzioni di configurazioni segnaliamo:

SyslogFacility/LogLevel per la configurazione dei log
Compression per abilitare o disabilitare la compressione dei dati trasmessi mediante gzip
PermitRootLogin per accedere al sistema come root
PasswordAuthentication e PubkeyAuthentication per abilitare/disabilitare l’autenticazione rispettivamente tramite password e tramite chiavi pubbliche (passphrase)
AllowUsers per riservare l'accesso esclusivamente agli utentispecificati. Possono essere utilizzati caratteri jolly (* e ?) e si può utilizzare anche la forma nomeutente@nomehost
AllowGroups come sopra per i gruppi.
DenyUsers e DenyGroups come sopra per negare l’accesso a utenti o gruppi.

La configurazione del client si trova in /etc/ssh/ssh_config e contiene molte opzioni come quelle già viste prima. Per la copia cifrata di file utilizzeremo il comando

$scp [opzioni] [[utente@]host:]origine [[utente@]host:]destinazione

Tra le opzioni abbiamo a disposizione la copia ricorsiva con –r. Per gestire sessioni di lavoro remote utilizziamo il demone screen. Per la gestione delle sessioni utilizzeremo le combinazioni di tasti:

Ctrl-a n: per avviare una nuova sessione
Ctrl-a w: mostra la lista delle finestre attive
Ctrl-a Ctrl-a: passa alternativamente alla finestra precedente o successiva.
Ctrl-a SPAZIO: passa alla finestra successiva
Ctrl-a numero tra 1 e 9: passa alla finestra numero specificato
Ctrl-a d : stacca (detach) la finestra dalla sessione di terminale
Ctrl-a l: blocca tutte le sessioni di terminale

3.0 Posta Elettronica

In generale un sistema di mail consiste di quattro componenti distribuite:

1) Un Mail User Agent (MUA) per leggere e comporre le mail
2) Un Mail Transport Agent(MTA) per instradare le mail
3) Un Delivery Agent per recapitare i messaggi
4) Un Access Agent, opzionale, per connettere l’utente al deposito dei messaggi.

Gli MTA più utilizzati sono sendmail , qmail e postfix. Troveremo il file di configurazione di postfix in /etc/postfix/mail.cf. Le impostazioni sono del tipo nome=valore e abbiamo a disposizione numerosi campi quali:

myhostname per il nome della macchina
mydomain per il dominio della macchina
mynetworks per l'elenco delle reti a cui è connessa la macchina
myorigin per il dominio da utilizzare per la posta in uscita
mydestination per i domini per cui si accetta la posta in arrivo.
notify_classes per impostare l'elenco delle categorie di problemi che vanno
segnalati alla casella del postmaster
alias_map e alias_database per il percorso dei file di alias.Di solito gli alias si trovano in /etc/aliases o /etc/postfix/alias

4.0 Apache

Apache è attualmente il server web più diffuso al mondo, è multipiattaforma e prevede il caricamento di moduli per la gestione di funzioni aggiuntive. Vediamolo brevemente in generale. Reperiamo dal sito www.apache.org in quanto è free e open source.
Il file di configurazione è httpd.conf , ma è possibile aggiungere file di configurazione esterni mediante la direttiva Include, direttive opzionali mediante la sintassi (ricordiamo che per via dell'interprete html del blog sostituito i simboli <> con i simboli _ e _

_IfDefine nome condizione_
.............
_ /IfDefine_

E direttive legati ai moduli aggiuntivi mediante

_ IfModule nomemodule _
.............
_ /IfDefine _

Alcune direttive di base sono elencate sotto:

ServerType { standalone inetd } per avviare il server in modalità standalone o legato a inetd.
ServerName per impostare il nome del server risolvibile mediante DNS.
Port, Listen per rimanere in ascolto della porta primaria o di porte aggiuntive
User, Group per impostare utente e gruppo per i permessi dei quali gira apache
CustomLog, ErrorLog per settare i file di log per gli accessi e per gli errori
DocumentRoot per impostare la radice del sito
Alias per definire gli alias per le cartelle
ScriptAlias per definire gli alias per le cartelle contenenti Script CGI (ovvero script che generano pagine html da comandi passati via form.
LoadModule per caricare moduli aggiuntivi

Le opzioni specifiche per una data cartella vengono indicate mediante la sintassi

_ Directory nomedir _
Opzioni....

_ /Directory _

Tra le opzioni abbiamo:

AllowOverride,Auth* per l’accesso.
Option: parametri (None: nessuno, All: tutti).
Indexes:per visualizzare il contenuto della cartella.
FollowSymLinks: segue i link simbolici.
SymLinksIfOwnerMatch: segue i link simbolici, se il proprietario coincide
ExecCGI: la cartella contiene script CGI che è possibile eseguire.
order: indica l'ordine con cui vengono considerate le direttive allow e deny.

Si possono utilizzare gli operatori + e – per aggiungere o togliere le opzioni per i livelli superiori.
Apache supporta il sistema di virual hosts per individuare ogni host con un indirizzo Ip differente o per identificare più siti con un IP. Gli host virtuali si definiscono mediante la sintassi

_ VirtualHost ip _
...
_ /VirtualHost _

Dove il valore ip deve coincidere con quello specificato nel parametro precedentemente settato

NameVirtualHost ip

Che indica l’indirizzo che rimane in ascolto delle richieste. Ricordiamoci che ogni host virtuale va configurato e ciò dipende dal tipo di versione Unix installata, solitamente mediante il comando ifconfig.

Gestione dei moduli del kernel

2009-03-21T17:47:00.002+01:00

Un kernel Unix tradizionalmente presenta una struttura monolitica. In questa struttura particolari componenti possono essere agganciati al kernel in runtime mediante chiamate di sistema. Questi componenti vengono chiamati moduli. La presenza dei moduli semplifica la realizzazione di nuovi componenti e permette di caricare in memoria solo quello che è richiesto, anche se questa operazione ha i suoi costi. I moduli vengono gestiti medianti appositi tools: modutils per i vecchi kernel e module-init-tools a partire dai kernel 2.6.x. Essi sono situati nella directory /lib/modules/_versione_del_kernel e sono in formato .o per i vecchi kernel e .ko per i nuovi. Per visionare i moduli presenti in memoria con i realtivi moduli dipendenti si impartisce il comando

$lsmod

Oppure

$modinfo [opzioni] modulo

Per le informazioni su un modulo specifico.

Per caricare un modulo in memoria si digita

$insmod [opzioni] modulo [parametri]

Impostando l’opzione –f si può forzare il caricamento del modulo ignorando eventuali errori.
Per rimuovere un modulo invece

$rmmod [opzioni] modulo

Anche qui vale l’opzione –f.
Il file modules.dep localizzato in /lib/version/_nome_versione_ , contiene le informazioni sulle dipendenze dei moduli. Il file può essere rigenerato con

$depmod [opzioni]

Il comando

$modprobe [opzioni] modulo [parametri]

Permette di caricare moduli o rimuoverli se si imposta l’opzione –r, risolvendo le dipendenze. Il file di configurazione di questo comando è modero.conf situato in /etc. Alcune opzioni sono:

options nome_modulo opzioni per aggiungere automaticamente le opzioni al modulo quando viene caricato

alias nome_alias nome modulo per dare un alias al modulo

include nome_file per aggiungere file di configurazione esterno

install nome_modulo comando per eseguire un comando al caricamento del modulo

remove nomemodulo comando si comporta come install per la rimozione del modulo.

Per compilare un kernel linux, si eseguono i passi:

$make xconfig

Se si esegue in X Windows altrimenti

$make menuconfig

Si impartisce poi

$make

O

$make install

E poi

$make modules_install

Scheduling dei Comandi

2009-03-21T17:44:00.001+01:00

Per rendere efficiente un sistema è necessario automatizzare buona parte dei compiti che vengono eseguiti con una regolare frequenza.Tali operazioni possono essere effettuate dai daemons. Di seguito vedremo alcuni demoni per l’esecuzione periodica dei comandi.
Cron è un demone che consente di pianificare l’esecuzione di determinati programmi. La configurazione di questi programmi si trova nel file /etc/crontab. Ogni utente può inoltre avere il proprio CRON mediante il comando crontab che memorizza il file di configurazione nella directory /var/spool/cron/crontabs. Questa possibilità può essere negata o consentita mediante la creazione di opportuni file in cron.deny e cron.allow nella directory /etc/. il file crontab presenta la seguente struttura:

minuto ora giorno mese giornosett utente comandi

Per i cron dei singoli utenti non è presente la voce utente. I campi relativi al tempo di esecuzione sono valori numerici che rispettano la semantica del campo stesso. Si può inoltre specificare un intervallo con il simbolo – all’interno di due valori, un qualunque valore con il simbolo * o ancora una serie di valori separati da una virgola. Il campo utente rappresenta l’utente per il quale si vuole attivare il comando, e comando l’operazione da eseguire. Alcuni comandi utili sono:

crontab -e modifica il proprio crontab
crontab -l visualizza il proprio crontab
crontab -r rimuove il proprio crontab

Un demone simile a cron è anacron, la cui frequenza di aggiornamento va specifica in giorni, e quindi assume che la macchina non resti sempre accesa. Il demone at esegue, invece, singoli comandi ad orari specifici presi da una coda di comandi. Come per cron è possibile avere demoni at personalizzati mediante la creazione di opportuni file at.deny e at.allow in /etc/.

File di Log

2009-03-21T15:16:00.000+01:00

I file di log hanno il compito di tenere traccia di errori e di particolari azioni compiute da alcune applicazioni. Contengono molte informazioni utile al fine di diagnosticare problemi e capire il comportamento delle applicazioni. Syslog è un demone che si occupa di gestire i log di sistema. Le distribuzioni Linux più recenti includono sysklogd che permette il log dei messaggi del kernel. In particolare vi è un file che permette di configurare le azioni da intraprendere in base all’evento di log ricevuto.Si tratta di syslog.conf. Ogni riga di questo file contiene due voci: una relativa al selettore e una relativa all’azione. La sintassi base di selettore è

facility.livello

facility indica la categoria di applicazione che ha inviato il log, ad esempio

– kern: kernel
– user: generici processi utente
– mail: server di posta e programmi accessori
– daemon: demoni di sistema
– auth: comandi relativi alla sicurezza
– local0, ..., local7: messaggi locali.
– ............
– * indica qualsiasi tipo.

Livello indica invece la gravità dell’azione. In ordine decrescente abbiamo

– emerg
– aler
– crit
– err
– warning
– notice
– info
– debug
-*

Le versioni più recenti introducono per i livelli i caratteri = e ! per rendere più flessibili i livelli.Inoltre sono ammessi più livelli separati da ; o ,.

Azione può,invece, assumere i valori

filename (percorso assoluto, anche un device)
@hostname, @ipaddress: verso il demone syslog della macchina specificata.
utente1 [, utente2, ...]: scrive un messaggio nella console degli utenti specificati
*: scrive un messaggio su tutti i terminali degli utenti connessi.

Per evitare che i file di log proliferino in modo incontrollato, il demone logrotate archivia e comprime i vecchi file di log in base ad un timer indicato. Questa e altre impostazioni sono archiviate in /etc/logrotate.conf . Questo file e tutti i file con le impostazioni relative ai programmi sono contenuti nella directory /etc/logrotate.d . Alcune opzioni sono:

Intervallo di rotazione: daily,weekly,monthly,
Size: limite di grandezza di un log oltre il quale scatta la rotazione.
postrotate/endscript: script da eseguire dopo la rotazione.
prerotate/endscript: script da eseguire prima della rotazione.

Script Unix

2009-03-21T13:47:00.007+01:00

Alla base della programmazione Unix vi è una filosofia per la quale tutto è realizzato mediante la composizione di programmi semplici, ciascuno specializzato per una particolare funzione. Tale filosofia prende il nome di KISS (Keep it simple stupid!). In questo post vedremo come realizzare dei semplici script. Il primo elemento con cui prederemo confidenza è la variabile. Una variabile si ottiene senza dichiarazione mediante il comando:

nome_variabile=valore

e se ne ottiene l’accesso mediante $

$nome_variabile.

Si può stampare a schermo il valore mediante:

echo $nome_variabile

o per maggiore chiarezza si può scrivere nella forma

echo &{nome_variabile}

Alcune variabili (PATH,HOME,PS1) hanno valore fondamentale per il sistema e si possono utilizzare mediante il comando set. Per permettere ad una variabile di essere utilizzata da altri programmi avviati dalla stessa shell, essa va esportata con

export nome_variabile

Alcuni lunghi comandi possono essere richiamati memorizzandoli come alias. Ciò può essere ottenuto con una semplice dichiarazione:

alias nome_alias=comando

Se vogliamo rimuovere un’alias scriviamo

unalias nome_alias

oppure

unalias –a

per rimuovere tutti gli alias. Alcuni caratteri hanno un preciso valore per la shell e sono detti metacaratteri; rimane comunque possibile privare il carattere del suo senso di metacarattere. Con il metacarattere

\

Seguito da un carattere, quest’ultimo perde il suo valore. Se invece racchiudiamo tra apici una sequenza di caratteri questi mantengono il loro significato letterale ad eccezione di $,’,/ ?

‘ ’

Con

` (apice inverso)

seguito da un comando, questo verrà sostituito dal suo output. In uno script i commenti vanno inseriti dopo un

#

Il primo rigo di un programma contiene un commento speciale chiamato bang path ed indica il nome del programma ed i suoi parametri. La shell mette a disposizione una serie di parametri predefiniti preceduti da $ Ad esempio:

$n : l’n-esimo parametro passato linea di comando. Se sono più di uno vanno racchiusi tra { }
$0: il nome dello script.
$* : se è utilizzato all'interno di apici doppi,indica un'unica parola contenente tutti i parametripassati a linea di comando, separati dal contenuto del primo carattere della variabile d'ambiente IFS. IFS normalmente contiene .
$@ : comportamento simile a quello di $* m a differenza di quest'ultimo, se utilizzato all'interno di apici doppi, rappresenta una lista di parole, una per ogni parametro.
shift num: trasla i parametri da [$#-num+1, $#] in [$1, $#-num].
$#: indica il numero dei parametri.

Per la selezione utilizzeremo il costrutto

if condizione
then comandi
[
elif condizione2
then comandi
]
else comandi
fi

Le condizioni possono essere comandi o serie di comandi legati da operatori logici che restituiscono 0 o 1. Se il valore restituito è 0 la condizione è vera altrimenti è falsa. Gli operatori logici sono &&,,&. In alcuni casi può essere utili ricorrere al dispositivo speciale /dev/null per sopprire l’output di un programma. Le espressioni aritmetiche possono essere eseguite mediante il comando let e i tradizionali operatori,eventualmente racchiuse tra (). È possibile, inoltre, utilizzare espressioni condizionali racchiudendole tra [] o utilizzando il comando test. Si possono usare i tradizionali operatori (==,!=,<,>) e altri quali

z stringa: controlla se stringa è vuota.
e file: controlla se file è vuoto.
d file: se file esiste ed è una directory.
file1 –nt file2: se file1 è stato modificato dopo file2.
……

Il ciclo for presenta una doppia sintassi:

for variabile [in lista]
do
comandi
done

e

for ((expr1; expr2; expr3))
do
comandi
done

In modo analogo i comandi while :

while listacomandirestituiscevero
do
comandi
done

e untill:

until listacomandirestituiscefalso
do
comandi
done

É possibile utilizzare anche il costrutto switch case mediante:

case parola in
[modello [ modello]... )
lista_di_comandi ;; ]
...
[*) lista_di_comandi ;; ]
esac

dove modello rappresenta un pattern. Le subroutine vengono definite con la sintassi:

[function] nomefunzione()
{
corpofunzione
}

E in questo caso le variabili $1,$2… tranne $0 si riferiscono ai parametri della funzione. Per le varaibili locali si usa la direttiva local. Gli input da tastiera vengono letti mediante il comando

read [opzioni] [nomevar1 nomevar2 ...]

Dove opzioni può assumere valori come:

-s per silent mode, come nelle password
-n num per la lettura di num valori.

Semplici menù interattivi sono impiegati mediante

select nomescelta [in lista]
do
comandi
done

Se “in lista” non è specificato, vengono utilizzati i parametri posizionali ($1, $2, ..). Altri utili comandi sono:

sort [opzioni] [file...] per l’ordinamento sul testo in input
find [percorso...] [espressione] ricerca file ed esegue comandi in corrispondenza di essi.
grep [opzioni] modello [file...] per la ricerca di sottostringhe.
sed [opzioni] [programma_di_elaborazione] [file...] per modificare al volo il testo ricevuto in input.

L’espressione regolare è un sistema di regole che permette di definire pattern di ricerca, ad esempio per cercare determinate occorrenze di caratteri in una stringa. Vedremo brevemente buona parte di queste regole. I caratteri che utilizzeremo per definire i pattern sono:

. per indicare un singolo carattere.
^ per indicare l’inizio di una riga.
\ per neutralizzare il metacarattere che lo segue.
$ per indicare la fine di una riga.
[] per indicare qualsiasi carattere racchiuso tra parentesi quadre. Con un trattino tra due caratteri si indica uno specifico intervallo.
[^] per indicare qualsiasi carattere esclusi quelli indicati tra paratesi quadre.
Due coppie di queste parentesi indicano una qualunque coppia tra un carattere di una coppia di parentesi e l’altra: ad esempio [ab][cd] vuol dire ac, ad, bc e bd. Stessa cosa per [^].

Per indicare il numero di occorrenze di un carattere utilizzeremo:

? per 0 o 1 occorrenza
+ per una o più volte.
* zero o più volte

Gestione file GNU/Linux

2009-03-21T11:37:00.006+01:00

In questo post vedremo come utilizzare i comandi per la gestione dei file. Il primo comando da analizzare sarà

$ls [opzione] [nome]

Impostando l’opzione –l ,esso fornirà in output informazioni sul file quali nome,tipo, permessi, quantità di collegamenti fisici, nome dell'utente proprietario, nome del gruppo, dimensione in byte, e data di modifica. Tali informazioni saranno rappresentate utilizzando per il tipo i caratteri:

d: indica una directory.
-: indica un file.
b: dispositivo a blocchi.
s: socket.
p: pipe.
l: link simbolico.

Per i permessi:

r: lettura.
w: scrittura.
x: esecuzione.
X: si comporta come x, ma interviene sulle directory e solo sui file che hanno già un permesso di esecuzione per un utente qualunque.
s: si applica solo i file eseguibili e le directory. Attiva il bit SUID o SGID a seconda se si agisce sull’utente, sul gruppo o su entrambi.
t: riguarda solo i file eseguibili e le directory. Attiva il bit Sticky.
u: attribuisce le stesse modalità dei permessi che ha già l'utente proprietario di quel file.
g: attribuisce le stesse modalità dei permessi che ha già il gruppo proprietario di quel file.
o:attribuisce le stesse modalità dei permessi che hanno già gli altri utenti per quel file.

Per le categorie di utenti:

u: proprietario.
g: gruppo.
o: altro.
a: tutti gli utenti.

In alternativa a ls è possibile usare stat per avere informazioni sui file in output formattato.
I caratteri di permessi possono essere considerati dei bit ( 4 per r, 2 per w e 1 per x), ed i permessi per ogni categoria di utenti come l’OR tra i bit relativi. Il comando chmod supporta entrambe le modalità. Esso va utilizzato con la sintassi

$chmod [opzioni] modalità file

Vediamo come esprimere la modalità:

-La combinazione di lettere u,g,o,a esprime la categoria di utenti.
-I segni +,-,= indicano il tipo di modifica sui cambiamenti e in particolare:
+: le modalità dei permessi indicati sono aggiunti a quelli precedenti.
-: le modalità dei permessi indicati sono tolti a quelli precedenti.
=: le modalità dei permessi vengono impostati esattamente come indicati.
-Il gruppo finale di lettere r, w, x, X, s, t, u, g, o indica i permessi su cui agire.

Il comando $umask [modalità] permette di impostare i permessi predefiniti per i file, ovvero i permessi impostati alla creazione del file stesso dal programma che lo ha generato. Solitamente la modalità va inserita in codifica ottale.
L’utente e il gruppo di appartenenza può essere modificato mediante i comandi chown e chgrp. La sintassi è

$chown [opzioni] nuovo_utente file

Oppure

$chown [opzioni] nuovo_utente nuovo_gruppo file

per cambiare anche il gruppo. Per chgrp la sintassi è

$chgrp [opzioni] nuovo_gruppo file

Vediamo alcuni comandi per operare con i file:

$cp [opzioni] file_sorgente file_destinazione

Copia un file dalla sorgente alla destinazione. Si possono utilizzare le opzioni –r per la copia ricorsiva e –a per la copia ricorsiva conservando i permessi.

$mv [opzioni] file_sorgente file_destinazione

Sposta un file se la destinazione è una directory altrimenti rinomina.

$rm file

Cancella un file.

$mkdir directory

Crea una directory

$rmdir directory

Elimina una directory vuota.

$ln [opzioni] target link_name

Tenta di creare un link fisico a target (target deve trovarsi nella stessa partizione). Con l’opzione –s crea un link simbolico.

$gzip [opzioni] nome_file

e

&gunzip [opzioni] nome_file

Rispettivamente comprimono e decomprimono un file alla volta sostituendo il file originale.
Analogamente a questi comandi è possibile utilizzare bizip2 e bunzip2 che sfruttano un algoritmo differente.

$tar [operazione] [opzione] file

Tar (tape archiver) è nato per gestire ( e lo fa tutt’ora) nastri di backup. In GNU permette di richiamare al volo gzip/gunzip o bizip2/gunzip2 con i parametri imposti –z e –j.

$zip [opzioni] file.zip [file…..]

Comprime in un archivio file.zip i file specificati.Come opzione è possibile utilizzare un intero tra -1 e -9 per indicare il tasso di compressione (come in gzip e bzip) o –r per la compressione ricorsiva. Per la decompressione si utilizza il comando unzip.

Vediamo adesso come gestire partizioni.

$mount [-o opzioni] [-t tipo] device punto_di_montaggio

Senza parametri mostra i file system montati. Se supportato dal kernel è possibile specificare un’immagine di file system tramite l’opzione loop.Il parametro [tipo] indica il tipo di file system. Il dispositivo può essere smontato mediante il comando

$unmount punto_di_ montaggio

Il comando

$df [-h]

Mostra l’occupazione del file system. Tutte le informazioni statiche del file system sono contenute nel file /etc/fstab/. I file system attualmente montati si trovano invece nel file /etc/mtab.Tali file pososno essere modificate per impostare le quote se supportate dal file system. Alcune opzioni importanti sono:

-noauto: disattiva il mounting automatico all’avvio del sistema.
-user: il file system relativo può essere montato dagli utenti senza però ulteriori modifiche.

Un controllo di accesso più dettagliato rispetto a quello standard è rappresentato da ACL (Access Control List). Tale sistema può essere attivato aggiungendo l’opzione acl nella relativa voce nel file fstab. Vediamo alcuni comandi:

$setfacl -m u:[utente]:permessi file1 [file2 ...] assegna i permessi ad utente
$setfacl -m g:[gruppo]:permessi file1 [file2 ...] assegna i permessi a gruppo
$setfacl -m o:permessi file1 [file2 ...] assegna i permessi agli altri
$setfacl -m m:permessi file1 [file2 ...] imposta la umask predefinita
$setfacl -x u:[utente] file1 [file2...] rimuove utente dall'acl
$setfacl -x g:[gruppo] file1 [file2...] rimuove gruppo dall'acl
$setfacl -b file1 [file2 ...] ripristina l'acl predefinita
$setfacl --restore=nomefile ripristina le acl salvate in nomefile, generate tramite getfacl –R. L’opzione –R indica l’applicazione ricorsiva.

Gestione degli Utenti in GNU/Linux

2009-03-19T16:44:00.005+01:00

1.0 Introduzione

Le operazioni di gestione degli user accounts sono di vitale importanza per un amministratore di sistema. In questo post vedremo come effettuare le operazioni fondamentali per la gestione degli utenti GNU/Linux. Il file /etc/passwd è un elenco mantenuto dal sistema per il riconoscimento degli utenti, ed è utilizzato per verificarne le credenziali.Ciascuna linea del file rappresenta un utente specifico ed è composto da 7 campi:

- username
- password crittografata
- numero UID
- numero di GID
- informazioni GECOS
- home directory
- shell di login

Il nome utente rappresenta il nome con cui l’utente effettua il login, solitamente non più lungo di 8 caratteri e deve individuare univocamente l’utente. Il campo password permette l’accesso al solo utente proprietario dell’account. Il numero UID è composto da un intero a 32 bit ed individua univocamente un account utente. Il GID è un numero ID identificativo di un gruppo utenti ed è espresso con un intero a 16 o 32 bit. Il campo GECOS memorizza una serie di informazioni personali quali nome,cognome e numero di telefono. Tutti gli utenti avranno una quota disco posizionata nella relativa directory individuata dal campo home directory. Infine il campo shell rappresenta l’interprete di comandi per ciascun utente. Il file /etc/shadow/ mantiene le informazioni relative alle scadenze delle password degli utenti. La scadenza della password permette di disabilitare l’accesso di un utente che non ha cambiato la sua password per un numero definito a priori di giorni..

2.0 Operazioni con gli utenti

Vediamo le operazioni di base per gestire utenti e gruppi. La prima operazione da apprendere è sicuramente l’aggiunta di un utente. Il comando che ci permette di farlo è useradd che può utilizzare tutti i parametri presenti nel file /etc/passwd. Per i parametri omessi verranno utilizzati valori di default. L’opzione –m permette di specificare la home directory dell’utente. È possibile utilizzare un frontend per la creazione degli utenti con adduser. Per la modifica e la rimozione degli utenti utilizziamo i comandi usermod e userdel. Quest’ultimo può utilizzare il parametro –r per eliminare tutti i file associati all’utente. I campi di /etc/shadow/ possono essere modificati con il comando chage. La password può essere modificata con il comando passwd, il quale chiederà l’inserimento della password due volte per avere conferma. I parametri –l e –u del comando passwd permettono di bloccare e sbloccare l’account.Il parametro –S, invece, visualizza lo stato dell’account. Il messaggio di benvenuto dell’utente si trova nel file /etc/motd. I gruppi si gestiscono con comandi equivalenti a useradd: groupadd per l’aggiunta, addgroup è, invece, il frontend interattivo, groupmod e groupdel per la modifica e l’eliminazione del gruppo. La quota disco può essere gestita in due modi. Il primo prevede un limite logico, superabile temporaneamente, ma che blocca l’account se superato per troppo tempo (tempo di grazia o grace time); il secondo impone un limite fisico invalicabile. Si possono impostare anche limiti per gli i-node. Abbiamo a disposizione i comandi:

$edquota nome_utente per impostare una quota per l’utente specificato.
$edquota –p utente_modello nome_utente per impostare la quota dell’utente specificato mediante modello.
$edquota –t per modificare il tempo di grazia per dimensioni e i-node. Per cambiare utente si può utilizzare il comando:

$su [opzioni] [-] [username [argomenti]]

Senza parametri avvia il processo per diventare superutente mediante l’inserimento di una password. Se si specifica il parametro [-], avvia una shell di login (leggere sotto),[argomenti] specifica i comandi da passare alla nuova shell

3.0 Shell di Linux

La shell, contentua nel file /bin/bash prevede due modalità di funzionamento:

-non interattiva: quando viene richiamata con un nome di file come parametro, la shell lo esegue come script

-interattiva: viene richiamata direttamente e presenta il prompt all’utente. Essa prevede due modalità:

-shell di login: invocata quando si conclude la fase di accesso al sistema, esegue al suo avvio i comandi contenuti nei file

/etc/profile

/etc/profile/.bash_profile

/etc/profile/.bash_login

/etc/profile/.profile

e alla sua uscita i comandi contenuti in

/etc/profile/.bashlogout.

-shell non di login: esegue i comandi contenuti in /etc/bash.bashrc e /etc/.bashrc

4.0 Il comando Sudo

Il comando sudo permette di eseguire comandi con i permessi di un altro utente. Esso richiede come argomento una linea di comando. Le persone autorizzate all’uso di sudo e i comandi che questi possono eseguire su ciascun host sono contenuti nel file /etc/sudoers. Se sudo viene eseguito correttamente ed i permessi sono validi, verrà richiesto l’inserimento della password. Le operazioni effettuate con questo comando vengono memorizzate in un file di log chiamato syslog o in un altro file scelto dall’amministratore. Rinviamo ad altri post l’uso del comando.

5.0 PAM (Pluggable Authentication Module)

PAM è una struttura utilizzata per la modifica in base al contesto della politica di autentificazione. I moduli sono contenuti nei file /lib/security/pam_*.so. mentre la configurazione per ogni servizio nei file /etc/pam.d/nomeservizio . Come per sudo rinviamo l’uso di PAM ad post successivi.

Gestione del software GNU/Linux

2009-03-18T18:08:00.004+01:00

In Unix sono stati sviluppati diversi sistemi per la distribuzione del software in forma binaria o sorgente. Di norma i programmi sono distribuiti sotto forma di pacchetti. I pacchetti vengono mantenuti in un archivio binario da un apposito software, generalmente preinstallato in molte distribuzioni, uno dei quali è RPM ( RPM Package Manager). In questo caso i pacchetti sono archiviati in formato cpio e per gestirli basta ricorrere ai seguenti comandi:

rpm –i [opzioni] nome_pacchetto.rpm per l’installazione del pacchetto.
rpm –u [opzioni] nome_pacchetto.rpm per l’aggiornamento.
rpm –e [opzioni] nome_pacchetto.rpm per la rimozione.

Alcune opzioni sono date da

-v e –h per una migliore visualizzazione dell’output.
--replacefiles per evitare la verifica di sovrascrittura dei files.
--nodeps per evitare la verifica delle dipendenze.

L’installazione fallisce se le dipendenze non sono soddisfatte salvo quando si specifica –nodeps. Adesso vediamo alcuni comandi per verificare i pacchetti.

rpm –V [opzioni] nomepkginstallato verifica lo stato del pacchetto installato(dimensione, file, permessi ecc).

rpm –Vf nomefile verifica il pacchetto che contiene il file specificato.
rpm –Vp nome pacchetto.rpm confronta il pacchetto specificato con quello installato.
rpm –Va verifica tutti i pacchetti installati.

Per interrogare i pacchetti possiamo utilizzare i comandi

rpm -qpi [opzioni] nome_pacchetto.rpm per interrogare il pacchetto non installato.
rpm -qpl [opzioni] nome_pacchetto.rpm visualizza i file del pacchetto non installato.

Per i pacchetti installati invece

rpm -qi [opzioni] nome_pacchetto visualizza informazioni relative al pacchetto.
rpm -ql [opzioni] nome_pacchetto visualizza i file del pacchetto.
rpm -qf nomefile visualizza i file del pacchetto che contiene il file specificato.
rpm -qa visualizza tutti i pacchetti installati

Il sistema di gestione dei pacchetti dpkg è nato per la distribuzione Debian ed è in grado di gestire i virtual packages. In pratica i pacchetti definiscono un campo Provides nelle informazioni e sono in formato ar. Per utilizzare i pacchetti si ricorre ai comandi

dpkg -i [altreopzioni] nome_pacchetto.deb per l’installazione
dpkg -r [altreopzioni] nome_pacchetto per la rimozione lasciando intatti i file di configurazione.
dpkg -p [altreopzioni] nome_pacchetto per la rimozione con i relativi file di configurazione.

Queste operazioni falliscono se le dipendenze non sono soddisfatte almeno ché non si specifichi l’opzione --force-all.

L’interrogazione dei pacchetti non installati avviene mediante i comandi :

dpkg -I [opzioni] nomepacchetto.deb per visualizzare le informazioni sul pacchetto.
dpkg -c [opzioni] nomepacchetto.deb visualizza ifile del pacchetto.
dpkg -x [opzioni] nomepacchetto.deb estrae i file del pacchetto.

Per quelli installati si abbiamo a disposizione i comandi:

dpkg -s [opzioni] nome pacchetto per visualizzare le informazioni sul pacchetto
dpkg -L [opzioni] nomepacchetto visualizza i file del pacchetto
dpkg -S nomefile visualizza il nome del pacchetto che contiene il file specificato.
dpkg -l visualizza tutti i pacchetti installati.

Un'altro sistema di gestione dei pacchetti, tipico delle distribuzioni slackware, è TGZ. Il sistema prevede una gestione minimale o addirittura assente della gestione delle dipendenze. I comandi per l'installazione, l'upgrade e la rimozione dei pacchetti sono in ordine

installpkg
upgradepkg
removepkg

Per la creazione di pacchetti rpm e deb è possibile specificare procedure da eseguire in diverse fasi, e precisamente prima dell'installazione, dopo l'installazione, prima o dopo la rimozione. Per i pacchetti tgz sono definiti solo script per le fase di pre-installazione e post-install.Questa procedura potrebbe comportare l'insorgere di alcuni problematiche quali la ricerca di pacchetti che risolvono le dipendenze o l'incompatibilità dei pacchetti tra le diverse distribuzioni. Per risolvere questi problemi solitamente si ricorre a sistemi dei gestione avanzata dei pacchetti (sistemi di secondo livello). Per i pacchetti dpkg e rpm si può ricorrere a APT (Advanced Package Tool). I comandi di apt sono:

apt-get install nomepacchetto per installare il pacchetto
apt-get update per aggiornare le informazioni sui pacchetti
apt-get upgrade per aggiornare i pacchetti alla versione più recentesenza installazioni o rimozioni
apt-get dist-upgrade per aggiorna il sistema alla versione più recente.
apt-get [--purge] remove nomepacchetto per rimuovere il pacchetto incluse le dipendenze. Se specificato --purge, rimuove anche i file di configurazione

Altre opzioni per apt-get install sono

-u : mostra tutte le operazioni che sta per effettuare e chiede come comportarsi.
-s : simula l'operazione senza effettuarla.
--download-only: scarica i pacchetti, senza installare.
-f: tenta di risolvere i problemi di dipendenza.

Un'altro Sistema di gestione dei pacchetti di secondo livello è YUM (Yellowdog Updater Modified), integrato in fedora con comandi simili ad apt:

-yum install nomepacchetto
-yum upgrade nomepacchetto
-yum remove nomepacchetto

Per le distribuzioni Mandriva (ex Mandrake) abbiamo a disposizione URPM con comandi:

-urpmi nomepacchetto
-urpme nomepacchetto
-urpmq nomepacchetto

APT e YUM mantengono informazioni sui pacchetti che possiamo richiamare rispettivamente con

– apt-cache search informazione
– yum search informazione

oppure

– apt-cache showshowpkg nomepacchetto
– yum info nomepacchetto

per ricevere tutte le informazioni di un pacchetto.Gentoo premette di utilizzare pacchetti precompilati o di ricompilare i sorgenti risolvendo le dipendenze mediante uno script in gradi di scaricare, decomprimere, compilare ed installare il pacchetto in modo automatico. I sorgenti sono distribuiti in archivi, e la loro gestione è stata semplificata nel tempo mediante l'introduzione di autotools che riducono le operazioni a tre semplici comandi

./configure [opzioni]
make
make install

J

2009-03-17T19:36:00.002+01:00

Job: Insieme di processi avviati mediante un unico comando di shell.

Processi in Unix

2009-03-17T19:24:00.000+01:00

1.0 Introduzione

Un programma singolo nel momento in cui viene eseguito si chiama processo. In Unix la nascita di un processo può avvenire mediante la richiesta di un altro processo. Il processo radice che da vita a tutti gli altri, come visto in post precedenti, è init. Il kernel mantiene una tabella dei processi e rende disponibili i suoi dati mediante un file system virtuale situato nella directory /proc/, all’interno della quale vi sono tante altre sottodirectory quanti sono i processi e hanno lo stesso numero del processo che identificano. Ogni sottodirectory contiene dei file relativi al processo in esecuzione.La morte di un processo provoca il così detto scarico di memoria o core dump. In pratica si crea un file contenente l’immagine del processo interrotto. Tale file permette di diagnosticare eventuale problemi che hanno provocato la terminazione del processo.

2.0 Gestione dei Processi

Vediamo alcuni comandi per gestire e lavorare con i processi. Il controllo dello stato dei processi può avvenire mediante i tre comandi:

$ ps : mostra un elenco dei processi e delle loro caratteristiche.
$ pstree : mostra l’albero delle dipendenze dei processi.
$ top: mostra in un terminale in tempo reale lo stato dei processi.
$ htop: come top ma consente l’uso di comandi interattivi.

I comandi possono ovviamente essere seguiti da opzioni. Con il comando

$pidof [name]

Si fornisce il PID del processo avente il nome che viene fornito.Con il comando

$fuser [file]

Si ottiene l’elenco dei processi che stanno utilizzando quel file.Il file aperti sono invece mostrabili con il comando

$lsof

Alcuni SIGNALS possono essere inviati mediante la pressione di combinazione di tasti:

Ctrl+c per il signal SIGINT, Ctrl+z per SIGTSTP, Ctrl+\ per SIGQUIT. Queste combinazioni possono essere modificate attraverso il programma $stty. In generale si possono inviare signals mediante

$kill [opzione/SIGNALS] [PID]

Adesso vediamo come gestire JOBS mediante la shell Bash. Ricordiamo che un JOB è un insieme di processi avviati da un unico comando di shell. Un JOB viene avviato in background aggiungendo a fine comando il carattere &. La shell restituisce il numero del JOB e il PID del processo terminale generato da questo job. L’elenco dei jobs può essere fornito mediante il comando

$jobs [opzione] [job]
Per portare in foreground ( in pimo piano) un job in background si invia il comando:

$fg [job]

Se non si specifica nessun job si intende il job attuale. Per riportarlo in background si usa invece

$bg [job].

Bootstrapping di Unix

2009-03-17T19:21:00.002+01:00

Si chiama bootstrapping la fase di accensione di un computer. Il termine deriva dall’espressione gergale da “to pull itself up by its own bootstraps”, letteralmente tirarsi su da solo dale cinghie dei propri stivali. La maggior parte dei sistemi Unix prevede due modalità di avvio: automatica e manuale. Nella prima il sistema compie il tutto senza ausilio dell’utente, nella seconda, ad una certa fase del caricamento, il controllo passa all’utente. In questa fase il sistema si trova in modalità monoutente (single user-mode), in cui la maggior parte dei processi di sistema non sono in esecuzione e altri utenti non possono accedere alla macchina. Analizziamo le diversi fasi di boot:

1 All’accensione della macchina, il controllo passa al codice contenuto nel chip ROM chiamato BIOS (Basic I/O System), che avvia una fase di inizializzazione della macchina e di test delle periferiche e dei componenti chiamata POST ( Power on self-test). Una lista definibile dall’utente contiene una lista di dispositivi da cui il BIOS avvia il caricamento del sistema.

2 Il primo settore del disco rigido (512 byte) viene chiamato MBR (Master Boot Record), e contiene le informazioni per la seconda fase di caricamento. A seconda del sistema installato è possibile scegliere anche quale sistema avviare attraverso un bootloader. LILO e GRUB sono due esempi di bootloader.

3 Il bootloader carica in memoria l’immagine del kernel del sistema operativo selezionato, se specificato, carica in memoria il file di initrd e cede il controllo al kernel. L’uso di initrd, evita di appesantire la dimensione del sistema o permette l’utilizzo di risorse esterne.

4 In questa fase il kernel richiama tutti i processi base, incluso init. Init ha il compito di creare tutti gli altri processi ed ha sempre PID 1. Questa fase può differire a seconda del sistema. Si differenziano due famiglie: BSD e SysV. In SysV, init definisce 7 livelli d’esecuzione (runlevel), ognuno dei quali definisce un insieme di servizi che dovrebbero essere eseguiti dal sistema. Il file /etc/inittab contiene le operazioni da fare per ciascun runlevel. In BSD non esiste l’idea di runlevel ma un unico script contenuto in /etc chiamato rc che avvia tutti gli altri script in un ordine prestabilito contenuti nella stessa directory.

File System di Unix

2009-03-17T19:18:00.001+01:00

1.0 Introduzione

In Unix il file system è rappresentato come una grande gerarchia che ha inizio con / (“root”) e prosegue con un numero arbitrario di sottodirectory. L’elenco ordinato di sottodirectory, a partire dalla root fino a quella presa in considerazione viene chiamato pathname, e permette di localizzare un file particolare. Un pathname può essere assoluto o relativo. Un pathname relativo viene interpretato tenendo conto, come punto di partenza della directory corrente. Per motivi di chiarezza tendo a distinguere i termini file, filename, path e pathname. Il file è un’insieme di dati binari che individuano un particolare elemento comprensibile dalla macchina. Tale insieme è caratterizzato da un nome che lo individua univocamente chiamato filename. Per poter raggiungere il file è necessario seguire un path; il pathname lo abbiamo definito in precedenza. Il file system può espandersi nella sua gerarchia a piacere in profondità ma ogni elemento del pathname non può superare i 255 caratteri, e l’intero pathname non può superare i 1023 caratteri. In presenza di pathname più lunghi è necessario posizionarsi in directory intermedie e procedere fino alla destinazione finale. Analizziamo alcuni path standard:

/bin: contiene i comandi fondamentali per il funzionamento di base del sistema. Non contiene sottodirectory.

/sbin: contiene comandi utili per l’amministrazione del sistema e il suo avvio. La divisione da /binè dovuta motivi di logistica.

/lib: contiene le librerie dinamiche del sistema e l’esecuzione dei programmi contenuti in /bin e /sbin. I moduli del kernel caricabili a run-time sono contenuti nella sub directory modules.

/boot: contiene i dati necessari per la fase di avvio del sistema.

/dev: contiene i file dei dispositivi.

/etc:contienei file di configurazione del sistema quali profili e password. La sottodirectory /X11 contiene i file di configurazione del sistema grafico.

/home: contiene le directory personali degli utenti, ad eccezione di quella dell’amministratore che è contenuta nella directory /root.

/mnt: utilizzata per montare i file system temporanei, ad esempio di altri sistemi operativi.

/media: contiene i dispositivi removibili.

/opt: utilizzata per i pacchetti software aggiuntivi.

/proc e /sys: tipiche di linux, contengono informazioni relative allo stato del sistema (cpu,moduli,processi..)

/tmp: contiene i dati temporanei richiesti da alcune applicazioni.

/usr: rappresenta una sorta di immagine della directory / .

/var: contiene le informazioni variabili, come file di log, directory di spool ecc.
Il kernel linux supporta numerosi formati di file system quali ext3,reiserfs,xfs,jfs.

2.0 Partizioni

Individuiamo tre tipi di partizioni: logiche, primarie ed estese. Le prime due contengono direttamente dati, la terza funge da contenitore di partizioni logiche. Sono presenti al massimo quattro partizioni tra primarie e logiche indicate con i numeri da 1 a 4, per un numero maggiore di partizioni è necessario definire ulteriori partizioni estese con all’interno le partizioni logiche la cui numerazione segue quella precedente. Una sola partizione primaria può avere la proprietà di “bootable”. Suddividere il file system in parizione multiple semplifica la fase di gestione, backup e controllo dello stesso.

3.0 I dischi

I dischi IDE sono identificati con hda per il disco primary master, hdb per il disco primary slave, hdc per il disco secondary master e hdd per il disco secondary slave. Se consideriamo il primo disco, le sue partizione primarie/estese saranno identificate da hda1, hda2 ecc. La numerazione delle partizione logiche partirà comuque da 5.

Esempi di Algebra relazionale

2009-02-28T21:42:00.005+01:00

Esempi di query in algebra relazionale con alcune equivalenti in SQL

1) Primo Esempio

Esempi di Programmazione Distribuita in JAVA e C

2009-02-22T22:46:00.005+01:00

Alcuni esempi per esplorare gli strumenti per realizzare programmi distribuiti in C e in JAVA. La parte relativa a C include esempi di thread.

esempi in C

esempi in JAVA

Equazioni di ricorrenza con metodo di sostituzione

2009-02-20T12:44:00.001+01:00

Alcune equazioni di ricorrenza risolte con il metodo di sostituzione.

Download

Il compilatore GCC e le nuove libc-dev

2009-02-16T15:16:00.009+01:00

Solitamente non mi occupto di HOW TO, ma in queste circostanze sono stato costretto a farlo.
Le nuove librerie di linux (linux-libcdev 2-6-27-11.27) hanno messo a dura prova la pazienza dei programmatori C, la mia in primis. Dopo numerosi tentativi di far eseguire un programma c basato sul parsing di messaggi tra un server e un client, e dopo un'approfondita ricerca sono emersi, a parte le informazioni, non adeguatamente diffuse, contenute nel seguente link i seguenti problemi:

1) non è possibile passare alla function gethostbyname una stringa che non sia stata già definita come array di caratteri. Ad esempio non è possibile scrivere gethostbyname("120.0.0.1") ma si deve scrivere: char []stringa="120.0.0.1"; ........ gethostbyname(stringa);

2) la chiamata accept manda in sospensione il programma in quanto non restituisce il valore -1 al termine delle richieste di accettazione.

3) la chiamata a read manda in sospensione il programma e il consiglio fornito dal link precedente non funziona.Si consiglia di leggere il contenuto del buffer e reinizializzarlo a buffer vuoto. La condizione di buffer vuoto non verrà modificata quando la read avrà cessato la lettura dello stream. Tale condizione può essere sfruttata per terminare il ciclo while.

Se emergeranno altri problemi li segnalerò.

I Java Servlet (Note Introduttive)

2009-01-31T14:18:00.005+01:00

Un servlet è un oggetto java caricato dinamicamente dal server su richiesta di un client. Sono in grado di gestire richieste multiple e si trovano supportati oggi da una moltitudine di web server. Così come le servlet per i server, per i client sono disponibili le applet. I servlet si basano sul sistema di comunicazione request-response tipico di HTTP, consentendo di generare contenuti dinamici come ad esempio pagine XHTML personalizzate, log-in sicuri, gestione di database con salvataggio della sessione utente e così via. Le classi e le interfaccie sono rese disponibili dai package javax.servlet e javax.servlet.http .La principale astrazione è l'interfaccia servlet. La maggior parte dei metodi da implementare ricevono due tipi di oggetti: una ServletRequest o una ServletResponse. La prima incapsula le informazioni dal cliente al server e consente di accedere ai valori passati dal client, al tipo di protocollo usato, all'indirizzo del client e all'input stream, mentre la seconda dal server al cliente e consente di impostare la risposta e accedere all'output stream. Per entrambe le classi esistono le sottoclassi con metodi specifici per il protocollo http: HTTPServletRequest e HTTPServletResponse. Solitamente tutti i metodi devono essere thread-safe, cioè in grado di gestire thread in modo sicuro ma è tuttavia possibile gestire le richieste una alla volta implementando l'interfaccia SingleThreadMode. Le servlet derivate dalle classi HTTPServlet devono realizzare ulteriori metodi per la gestione delle richieste tipiche di HTTP quali HTTP GET, HEAD,POST,PUT e DELETE. Rimandiamo a successivi post le specifiche sui metodi da utilizzare.

R

2009-01-29T21:36:00.006+01:00

Resilienza: capacità da parte di un sistema o infrastruttura di rispondere con elasticità alla variazione di carico applicativo.

RIA(Rich Internet Application): web application che possiedono le caratteristiche e le funzionalità tipiche di applicazioni desktop. Sono esempi di piattaforme RIA Microsoft Silverligth e AdobeFlex. Le applicazioni RIA sono alla base del cloud computing.

RMI(Remote Method Invocation): Invocazione di metodi remoti. Sistema software orientato agli oggetti che permette ad un host di invocare un metodo su un host remoto come se il metodo si trovasse sulla macchina locale. E' un sistema simile al RPC(vedi) per i linguaggi orientati agli oggetti.

RPC (Remote Procedure Call): Chiamata a procedura remota. Sistema sofware il cui scopo è quello di permettere ad un host di eseguire una procedura in un host remoto come se la procedura si trovasse nella macchina locale, nascondendo quanto più possibile i meccanismi che permettono tale operazione.

Remote Method Invocation (RMI) in breve

2009-01-29T21:33:00.004+01:00

Un'applicazione RMI è un applicazione distribuita orientata agli oggetti. Solitamente consta di un server che crea oggetti remoti, ne rende accessibili i riferimenti e attende di servire un client che ne invochi i metodi, e di un client che ottiene riferimenti a tali oggetti remoti e ne invoca i metodi. In questo caso parleremo di oggetti e metodi remoti. I componenti di applicazioni RMI possono rivestire simultaneamente i ruoli di client o server perciò le definizioni precedenti vanno applicate a seconda dei ruoli rivestiti nel momento considerato. Così come abbiamo visto nei sistemi RPC anche nel RMI i meccanismi di invocazione remota sono resi trasparanti da un servizio di astrazione fornita dagli oggetti remoti. Il servizio rmiregistry, consente ad un client di ottenere riferimenti ad oggetti remoti.Esso costituisce un server dei nomi per gli oggetti, individuati da un nome rappresentato in stringa. Un server può registrarvi un oggetto associandolo al suo nome (object binding), il client può invocarne i metodi ricevendo il riferimento in cambio del nome. Inizialmente è il servizio rmiregistry a fornire il primo riferimento remoto, dopo il client può ottenerne altri chiamando metodi di oggetti remoti che forniranno riferimenti ad altri oggetti remoti. I riferimenti infatti possono essere utilizzati come parametri di metodi remoti. Una classe non remota MyClass può trasferire il suo bytecode dal client al server e viceversa attraverso il sistema RMI, anche attraverso il protocollo http e web server. Nel caso da client a server il trasferimento può aver luogo se un oggetto non remoto figura come parametro di un metodo remoto invocato dal client; nell'altro caso se l'oggetto è restituito da un metodo remoto eseguito sul server. Gli oggetti vengono passati con il loro vero tipo e ciò garantisce assoluta trasparenza, semplicità e dinamicità. Come una qualuque applicazione Java un'applicazione RMI è costituita da interfacce e classi che implementano tali interfacce. Un'oggetto è remoto se la sua classe implementa l'interfaccia java.rmi.remote. E' importante ricordare che gli oggetti remoti e il bytecode si trovano sulla macchina server e non vengono copiati sul client ma esso realizzerà un client stub che rappresenta l'implementazione locale dell'interfaccia implementata realmente nel server, fa da ponte alle chiamate agli oggetti remoti e provvede al marshalling/unmarshalling dei parametri attuali /risultati. I passi da seguire per realizzare un'applicazione RMI sono solitamente i seguenti: si progetta e si realizza il client, il server, l'interfaccia remota e la sua implementazione; si compilano i sorgenti; si genera con rmic le classi client stub; si distribuiscono i bytecode (cliente,interfaccia remota e stub nel client, il server,lo stub, l'interfaccia e la sua implementazione nel server); si esegue l'applicazione sia dal lato client che dal lato server.

Socket in JAVA

2009-01-07T11:05:00.003+01:00

1.0 Indirizzi IP

La classe InetAddress viene utilizzata per rappresentare gli indirizzi IP delle macchine. Il metodo statico

static InetAddress getByName(String hostname)

restituisce un’istanza di InetAddress rappresentante l’host specificato. Per ottenere l’indirizzo di default dell’host locale si passa come parametro null. Il metodo

public static InetAddress getByAddress(byte[] addr)

restituisce un’istanza di InetAddress rappresentante l’indirizzo IP dell’host locale. Con

public static InetAddress[] getAllByName(String hostname)

si ottiene un array contenente istanze di InetAddress utili nel caso di più indirizzi IP associate ad un hostname. Il metodo statico

public static InetAddress getLocalHost()

restituisce un InetAddress per la macchina locale. Se la macchina non è registrata o è protetta da firewall l’indirizzo è quello di loopback. Loopback è un meccanismo di test che cattura i messaggi inviati all’host locale e li rispedisce al mittente. Tutti questi metodi possono sollevare l’eccezione UnknowHostException se non sono in grado di risolvere l’indirizzo.

2.0 UDP in JAVA

In java in pacchetti UDP sono rappresentati mediante la classe DatagramPacket. Dal lato client, è sufficiente richiamare il costruttore

public DatagramPacket(byte buf[], int length,InetAddress address, int port)

Dove buf, rappresenta il messaggio, lenght i suoi primi length byte, address l’indirizzo IP e port il numero di porta.

Dal lato server,useremo il costruttore

public DatagramPacket(byte buf[], int length)

La classe DatagramPacket ci mette a disposizione metodi quali:

InetAddress getAddress()

Restituisce l’indirizzo IP della macchina che ha mandato o ricevuto il pacchetto.

void setAddress(InetAddress addr)

setta l’indirizzo IP della macchina.

int getPort()

restituisce il numero di porta della macchina remota.

void setPort(int iport)

setta il numero di porta.

byte[] getData()

restituisce i dati del pacchetto.

void setData(byte[] buf)

setta i dati del pacchetto.

3.0 Socket Multicast

È possibile mandare un pacchetto a più host con una sola invocazione di metodo. La libreria java.net mette a disposizione la classe MulticastSocket a tale scopo. Chi riceve i pacchetti multicast oltre a conoscere la socket del server deve conoscere l’indirizzo del gruppo al quale viene inviato il pacchetto. Per creare una socket multicast si seguono i passaggi:

1. Creazione di un indirizzo di gruppo con

InetAddress gruppo = InetAddress.getByName(ind)

2. Creazione di una socket per il multicast con

MulticastSocket msocket = new MulticastSocket(porta)

3. Connessione della socket al gruppo con

msocket.joinGroup(gruppo)

Tutti i processi che eseguono una joinGroup() possono ricevere i pacchetti invocando una

msocket.receive(packet);

e possono abbandonare il gruppo con una chiamata a

msocket.leaveGroup(gruppo)

Il processo server può inviare pacchetti multicast seguono le operazioni

1) Creazione del gruppo con

InetAddress group = InetAddress.getByName(ind);

2) Creazione della socket con

MulticastSocket msocket = new MulticastSocket(porta);

3) Partecipazione al gruppo con

msocket.joinGroup(group);

4)creazione del pacchetto con

DatagramPacket packet =DatagramUtility.buildPacket(group, porta, linea);

5)Invio del pacchetto

msocket.send(packet);

I metodi della classe MulticastSocket sono così riassunti:

joinGroup(InetAddress addr) throws IOException
leaveGroup(InetAddress addr) throws IOException
send(DatagramPacket p)
setTimeToLive(int tlive) throws IOException

setta il tempo di vita per i pacchetti multicast mandati sulla socket(tlive deve essere compreso tra 0 e 255)

int getTimeToLive() throws IOException

restituisce il tempo di vita.

Trovere l'implementazione della classe DatagramUtility in questo blog, nella sezione SoftPedia

4.0 Stream Socket

Server e client instaurano un tipo di connessione che prevede due flussi di dati, uno per l’input e uno per l’output. Le API sono distente per il client e per il server: nel primo caso è la classe Socket, nel secondo ServerSocket. Una connessione è individuata da 4 elementi: indirizzo IP e porta,sia per il server che per il client. Per instaurare una connessione il client esegue l’istruzione:

Socket socket = new Socket(addr, PORT);

La connessione va terminata direttamente per non impiegare inutilmente risorse di sistema attraverso close(). Il client può ricevere flussi di dati con

InputStreamReader isr = new InputStreamReader(socket.getInputStream());

che permette di convertire un flusso di byte in caratteri.Per migliorare l’efficienza si può ricorrere ad un buffer

BufferedReader in = new BufferedReader(isr);

Per leggere una striga dallo stream si usa:

String s = in.readLine()

Il client può creare uno stream di output verso il server in modo analogo allo stream di input:

OutputStreamWriter osw = new
OutputStreamWriter(socket.getOutputStream());
BufferedWriter bw = new BufferedWriter(osw);
PrintWriter out = new PrintWriter(bw, true);
out.println(s)

Quando ha terminato bisogna chiudere gli stream e la socket:

out.close();
in.close();
socket.close();

Il server invece deve creare un’istanza di SocketServer con

ServerSocket serverSocket = new ServerSocket(PORT);

e rimanere in attesa di connesione con

Socket clientSocket = serverSocket.accept()

Con

setSoTimeout(t)

si può ritardare una accept() per t millisecondi. Con una accep() si restituisce un oggetto di tipo Socket che permette al server di usare gli stream che il client ha stabilito. I metodi sono gli stessi visti prima.

Principi di RPC (Remote Procedure Call)

2009-01-06T16:45:00.007+01:00

Funzionamento di una RPC (Remote Procedure Call)

La maggior parte dei sistemi distribuiti si basano sullo scambio di messaggi ma spesso le procedure send e receive non consentono la dovuta trasparenza che si desira. Nel 1984 Nelson e Birrel introdussero un nuovo modo di gestire la comunicazione che prevede la possibilità dai parte dei programmi di chiamare procedure su altre macchine. Tale metodo prese il nome di Chiamata a Procedura Remota (RPC). L’idea alla base delle RPC prevede di rendere una chiamata a procedura remota quanto più simile ad una chiamata locale. Quando una di queste chiamate viene effettuata, la procedura client richiama una procedura detta client stub, la quale costruisce un messaggio, richiama il sistema operativo locale che invia il messaggio al server stub. Il server stub ha il compito di spacchettare i parametri contenuti del messaggio, richiama il server che elabora il risultato, lo impacchetta in un nuovo messaggio e richiama il sistema operativo che ha il compito di inviare il messaggio al SO del client. A questo punto non resta che accettare il messaggio e inviarlo al client stub che spacchetta il messaggio e lo restituisce al client. La fase di realizzazione del messaggio contenente i parametri è piuttosto elaborata e viene chiamata marshaling dei parametri. I problemi si possono verificare quando le macchine client e server sono differenti per architettura, come nel caso delle macchine little indian e big indian, oppure quando si utilizzano codifiche differenti. Un'altro problema si verifica quando è necessario passare un puntatore. Il passaggio dei parametri referenza in realtà nelle RPC viene sostituito da meccanismi di copia/ripristino. Ad esempio l'invio di un puntatore ad un array comporta l'invio dell'intero array al server e la conversione del valore numerico del puntatore con il dato puntato. Questo meccanismo, di contro, non può essere applicato a strutture dati arbitrarie come grafi. Alcuni sistemi ad esempio affrontato il problema inviando il puntatore al server stub che richiede l'invio dei dati referenziati al client. Un IDL, (Interface Definition Language) serve a definire il nome,la versione e il prototipo o signature di un servizio RPC. Mediante tali informazioni contentute nel file di definizione di un servizio RPC, il compilatore d'interfaccia (interface compiler), ad esempio l' rpcgen di Sun RPC, è in grado di generare due moduli, il primo detto client stub, quando il client invoca la funzione remota ( in concreto invoca la funzione dello stub che permette di nascondere il meccanismo di chiamata remota), il secondo detto server stub o skeleton, che invoca la funzione corrispondente a quella chiamata dal client (mediante la request ricevuta dal client stub). Vengono generate inoltre le dichiarazioni dei tipi e delle procedure traducendole dall' IDL solitamente in un header file. Alcuni IDL permettono di scrivere server e client in linguaggi differenti. Il sistema RPC è fornito di tecniche di controllo di errori di comunicazione. E' in grado di rispedire le richieste finchè non ottiene risposta ( request retry), riconosce quelle duplicate ( duplicate request filtering). Vediamo i passi da seguire ( in linea generica e non specifica) al fine di realizzare un'applicazione client-server. Il primo passo è sicuramente quello di generare il file IDL e compilarlo. Generati il client stub, il server stub e l'header file si utilizza la direttiva #include per inserire l'header nel codice del client e del server. Bisogna poi scrivere il codice del client e del server e linkarli. Una volta generato il codice binario è possibile avviarli per rendere disponibile l'applicazione.

Libreria Linux-Thread ( Prima parte)

2008-11-17T22:35:00.005+01:00

A differenza dei processi, i threads non hanno necessità di uno spazio di indirizzamento privato, ma uno spazio in comune che utilizzano per la comunicazione (scambio di dati). Riassumiamo alcune delle differenze principali tra processo e thread. La creazione di un thread è generalmente più rapida di qulla di un processo, in quanto utilizza lo stesso spazio di indirizzamento del suo processo genitore. Di conseguenza risulta più rapido anche il tempo di terminazione e lo switch tra più threads. Più rapido sarà invece il tempo di comunicazione. La libreria che analizzeremo di seguito è quasi del tutto conforme agli standard Posix per i thread. Ove ciò non sarà così verrà specificato. La libreria Linux-Thread segue un modello chiamato 1-to-1, in cui ogni thread è in realtà un processo nel kernel. Per ulteriori informazioni sui processi in unix rimandiamo ai post dell’archivio Sistemi Operativi. Vediamo subito come creare e gestire thread.

1.0 Creare Thread

Per creare un thread, dopo aver importato la libreria pthread.h, si può ricorrere alla funzione:

int pthread_create( pthread_t * thread, pthread_attr_t * attr, void * (*start_routine)(void *),void * arg );

dove thread è l’identificatore del thread creato, attr è il puntatore agli attributi del thread, start_routine è un puntatore alla funzione che il thread eseguirà, arg è l’argomento da passare a tale funzione. Se la funzione restituisce un valore diverso da zero, allora se il valore restituito coincide con EAGAIN vuol dire che non ci sono risorse disponibili da allocare per il nuovo thread o che si è raggiunto il numero massimo di thread creati. Per uscire dal thread basta ritornare dalla funzione start_routine oppure chiamando pthread exit().

2.0 Attributi dei thread

Vediamo gli attributi dei thread. Per inizializzare gli attributi da passare come argomento al thread utilizzeremo

int pthread_attr_init(pthread_attr_t *attr);

e li distruggeremo con

pthread attr destroy(&a);

Gli attributi sono elencati di seguito:

• detachstate
• schedpolicy
• schedparam
• inheritsched
• scope

l’int detachstate può assumere i valori PTHREAD_CREATE_ JOINABLE (default) o
PTHREAD_ CREATE_ DETACHED. In questo caso se il thread t è joinable, un altro thread può con pthread join(t,...), sincronizzarsi sulla terminazione di t ed ottenerne l’ exit code.Le risorse di t vengono recuperate solo quando viene eseguito un pthread join(t,...) e non alla sua terminazione.
L’int schedpolicy può assumere invece i valori SCHED_OTHER per lo scheduling standard di Linux, SCHED_FIFO se si desidera che un thread in testa alla lista di scheduling giri fino al completamento, al blocco per I/O o alla rinuncia oppure per preemption da parte di un processo di maggior priorità, SCHED_RR per lo scheduling realtime o round-robin. Per quanto riguarda la struct sched_param schedparam ,i suoi membri codificano i parametri della scheduling policy. L’int inheritsched vale PTHREAD_EXPLICIT_SCHED o PTHREAD_ IMPLICIT_ SCHED se le policy e parametri di scheduling sono rispettivamente definiti dai relativi attributi (default) o ereditati dal thread padre. L’ int scope definisce l’ambito della contesa per lo scheduling e vale PTHREAD_ SCOPE_SYSTEM (default) o PTHREAD_ SCOPE_PROCESS.

3.0 Operazioni con i Thread

Esaminiamo alcune function per operare con i thread:

-pthread_t pthread_self(void);

permette di restituire il thread corrente.

void pthread_exit(void *retval);

permette di uscire dal thread corrente. Non restituisce nessun valore ma permette ad altri thread di accedere a retval attraverso la chiamata pthread_join();

int pthread_join(pthread_t th,void **thread_return);

rende il thread detached. Se lo è già restituisce errore EINVAL.

int pthread_join(pthread_t th,void **thread_return);

sospende il thread a favore di th finchè questo non viene eliminato o termina la sua esecuzione. Se thread_return è diverso da NULL,nela locazione a cui punta andrà il (void * val) restituito dal thread th, con pthread exit(val) oppure PTHREAD_CANCELED se th viene cancellato.

int pthread_cancel(pthread_t cth);

Invia una richiesta di cancellazione a cth che può ignorare onorare a seconda se il suo stato lo permette. La cancellazione ha effetto immediato se il canceltype di cth è PTHREAD_CANCEL _ASYNCHRONOUS, o rimandato al prossimo check point di cancellazione se il canceltype è PTHREAD_CANCEL_DEFERRED. Lo stato e il tipo di cancellazione va settato con le function

int pthread_setcancelstate(int state,int *oldstate);

int pthread_setcanceltype(int type,int *oldtype);

dove oldtype può essere nullo se non si vuole memorizzare il checkpoint precedente.

4.0 Mutex

In C è possibile implementare mutex. Una variabile x può essere protetta da mutex con la chiamata

int x;

pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;

e gli accessi regolati con

pthread_mutex_lock(&mut);

pthread_mutex_unlock(&mut);

Le operazioni di lock e unlock sono sempre relative alla viariabile x precedentemente creata. Si possono realizzare mutex con l'istruzione

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr);

mutexattr può essere nullo, se si vogliono gli attributi di default. L'unico attributo supportato da LinuxThread è il mutex kind che può valere

PTHREAD_MUTEX_FAST_NP per il tipo fast,
PTHREAD_MUTEX_RECURSIVE_NP per il tipo recursive,
PTHREAD_MUTEX_ERRORCHECK_ NP per il tipo error checking.

Il suffisso NP indica che non sono estensioni portabili in POSIX. Gli effetti di bloccaggio su un mutex gìa bloccato variano secondo il tipo di mutex. Se il mutex è di tipo fast, la chiamata viene sospesa finchè non si sblocca causando un deadlock; se invece è di tipo error checking, restituisce un errore EDEADLK; se invece è tipo recursive, verrà memorizzate il numero di volte che il thread chiamante ha chiamato il lock, e sbloccherà il mutex solo quando il numero di volte che è stato sbloccato coincide con il numero di volte che è stato bloccato. Esiste anche una chiamata

int pthread_mutex_trylock(pthread_mutex_t *mutex);

che non blocca il thread chiamante se il mutex è già bloccato da un'altro thread. Una situazione simile a quella vista prima si verifica se si tenta lo sbloccaggio di un mutex. Se il mutex è di tipo fast, viene sbloccato; se il mutex è di tipo error checking controlla che il thread chiamante sia lo stesso che lo ha bloccato, restituendo un errore in caso negativo e lasciando invariato il mutex; se è di tipo recursive decrementa il contatore del numero di volte che è stato chiamato lo sbloccaggio, sbloccando il mutex se il suo valore dovesse essere 0.Un mutex può essere distrutto con la chiamata

int pthread_mutex_destroy(pthread_mutex_t *mutex);

Modelli di Processo Personali e a Team

2008-10-31T09:13:00.007+01:00

Il miglior processo di sviluppo è, sicuramente, quello che più si adatta alle persone che stanno sviluppando, quello che può essere meglio adattato ai bisogni, alle esperienze, alle conoscenze del team di sviluppo. Ogni ingegnere dovrebbe essere in grado di elavorare un processo alla luce di tali considerazioni.

1.0 Processo di Sviluppo Personale ( Personal Software Process)

Risale ad Humphrey (1997) e pone l'accento sulla valutazione personale di ogni singolo componente del team sul prodotto e sulla sua qualità, rendendolo responsabile della sua pianificazione e incaricandolo di controllarne la qualità in ogni sua singola parte. Il modello PSP prevede le seguente fasi:

-Pianificazione

-Progettazione ad alto livello.

-Revisione della progetto ad alto livello.

-Sviluppo.

-Revisione del Codice.

-Post-Mortem o Rilancio.

Ciascuna fase segue delle linee guida definita da uno Script o guida al lavoro. L'evoluzione PSP porta alla stesura di un log in diverse versioni (PSP 0, PSP 0.1, PSP 1.0,PSP 1.1 .... , PSP 3.0 ) che prevede il tempo impiegato, i difetti emersi e la verifica del lavoro compiuto.

2.0 Processo di Sviluppo a Team (Team Software Process)

I concetti di PSP posso essere estesi ad un altro processo, il processo TSP. Si basa sulla costruzione di team auto-diretti che pianificano e monitorizzano il proprio lavoro, su team-leader che sappiano motivare e sostenere i propri collaboratori, portando ad un miglioramento della qualità e della quantità produttiva della squadra. E' un modello che si estende sia ai piccoli che ai grandi team. Affinchè il modello sia valido sono necessari alcuni prerequisiti:

- I membri hanno i requisiti necessari.

- L'obbiettivo è ben definito, reale e comune a tutti i membri.

-I membri sono disciplinati nel loro lavoro.

-I membri sono motivati e collaborativi tra loro.

- Il modello organizzativo del team è simile al modello Closed.

E' fondamentale la comunicazione tra i membri del team. Essi devono essere aggiornati constantemente sullo stato del progetto attraverso meeting e report settimanali per essere sempre a conoscenza sul progresso del team. Anche i clienti vanno aggiornati mediante report periodici. I membri del team devono fidarsi tra loro e le loro competenze devono essere appropriate al problema da risolvere. La comunicazione e l'interazione devono evirare tutte le "tossine" che creano problemi, ritardano il progetto o ne degradano la qualità. Lo scopo del leader è quello di motivare e guidare il team, mantenere la disciplina al progetto, gestire i problemi e le questioni sollevate dal team.

3.0 Da PSP a TSP

Prima che i membri possano partecipare al team devono essere allenati nel modello PSP. La costruzione del team è un processo che dura 4 giorni e viene detto lancio del team. Poichè il modello TSP è un modello che segue una strategia di sviluppo iterativa ed evolvente il lancio del team avviene ciclicamente in moda tale che ogni lancio possa essere programmato in base ai risultati e all'esperienza ottenuta nel lancio precedente. Segue uno schema riassuntivo della formazione del team secondo Humphrey.

Sotto la tabella riassuntiva dei quattro giorni della costruzione del team. I criteri iniziali prevedono la convocazione dei membri del team, dei rappresentati gestionali e del marketing e l'elezione di un coach per condurre il processo stesso.

Tipologie e Modelli organizzativi dei Team

2008-10-24T18:20:00.008+02:00

1.0 Tipologie di Team

Nonostante il team sia una organizzazione complessa e profonda in quanto composta da uomini è possibile individuare tre modelli principali. Essi sono soltanto dei punti di riferimento, poiché un vero team può essere una fusione di tali modelli o una continua alternazione degli stessi.

· Democratica Decentralizzata

È la tipologia di team più dinamica. Non presenta mai un leader fisso ma solo capo-gruppi temporanei. Si fonda sulla comunicazione diretta e orizzontale trai membri e le decisioni vengono proposte, accettate o bocciate dall’intera comunità

· Controllata Decentralizzata

Presenta un leader fisso che vigila su sottogruppi organizzati nel modello Democratico Decentralizzato.

· Controllato Centralizzato

Si fonda sulla gerarchia indiscutibile del gruppo. Costante è la presenza di un leader le cui decisioni non vengono mai messe in discussione.

2.0 Paradigmi di Organizzazione

Anche il modo di rapportarsi con l’esterno e con l’interno può essere individuato da precisi modelli. Si ricorda che anche in questo caso nei team reali non esistono modelli precisi ma tale divisione permette di analizzare meglio la vita di gruppo di una squadra.

· Random

In antitesi con closed, è il tipo di organizzazione adatto alla ricerca e allo sviluppo. Si fonda sull’innovazione, sull’indipendenza e sull’abilità individuale dei membri del gruppo.

· Closed

In antitesi con Random, si fonda su regole e norme precise e ben definiti, sul filtraggio delle informazioni e sulla fedeltà dei membri del gruppo. Non ammette iniziative personali né forme di concorrenza tra i vari membri.

· Synchronized (o di Constantine)

In antitesi con Open, prevede la totale assenza di interazione tra i membri del gruppo ai quali vanno consegnate le parti da svolgere e consegnare.

· Open

In antitesi con Synchonized, si fonda sulla cooperazione, sulla condivisione di mezzi e informazioni con i membri del gruppo e con l’esterno.

È possibile schematizzare le caratteristiche salienti dei paradigmi di Organizzazione nel seguente link Download .

Le componenti fondamentali dello sviluppo del software vengono chiamate 4P:

Persone: tutti i membri coinvolti direttamente o indirettamente nello sviluppo di un prodotto.

Prodotto: il frutto del lavoro di tutte le persone coinvolte nello sviluppo.

Processo: l'insieme di tutte le attività strutturali, dei lavori di ingegneria e quant'altro garantisca il prodotto finale.

Progetto: il lavoro richiesto per realizzare il prodotto.

3.0 Stakeholders

Gli stakeholders rappresentano tutte le persone coinvolte direttamente o indirettamente nel processo di sviluppo del software. Si possono classificare in:

Senior Manager: rappresenta il contesto aziendale ed influenza in maniera significativa la realizzazione del software.

Project Manager: pianifica,coordina e motiva il personale tecnico coinvolto nel progetto.

Tecnici: coloro che implementano il software.

Clienti: commissionano e specificano i requisiti del software.

Utenti finali: sono i destinatari e gli utilizzatori del software e possono coincidere con i clienti.

4.0 Modello MOI

Il modello MOI rappresenta la caratteristiche che un leader deve avere. Esse sono la motivazione, ovvero la capacità di incoraggiare e guidare i tecnici, l'organizzazione, cioè la capacità di elaborare le idee e finalizzarle per completare il prodotto finale, l'innovazione, ovvero la capacità di creare e di essere creativi anche quando bisogna muoversi entro limiti ben definiti.

Al fine di garantire un prodotto soddisfacente vanno tenute in considerazioni diverse variabili come la difficoltà del prodotto da realizzare, la dimensione dello stesso, la durata del team, ovvero il tempo per cui si può disporre del personale, la modularità del problema da affrontare, la qualità e l'affidabilità del prodotto da consegnare, la rigidità dei tempi di consegna e il grado di comunicazione tra il personale richiesto. Inoltre vanno tenuti in considerazione elementi quali l'attività frenetica, il dispendio di energie, la frustrazione legata a fattori di inconcludenza, l'attrito,la scarsa definizione dei ruoli del personale e la frammentazione del processo software. Tutti questi fattori possono portare al fallimento e sono stati definiti fattori di tossicità.

Introduzione alla documentazione per lo sviluppo di un software

2008-10-24T17:50:00.001+02:00

1.0 Documentazione

La documentazione di un software consente alla direzione di controllare e pianificare lo sviluppo del progetto e di analizzare a posteriori tutto ciò che è stato fatto o non fatto al fine di migliorare e ottimizzare sia l’organizzazione che il processo di produzione del software. Si producono due tipi di documenti, quelli inerenti il management del progetto e la documentazione vera e propria.

· Management del progetto

-Organigramma
-Diario di progetto
-Verbale
-Piano di progetto
-Norme di progetto
-Offerta
-Piano di gestione della qualità.

· Documentazione del progetto

-Analisi del Dominio
-Analisi dei Requisiti
- Specifica architetturale
-Specifica di dettaglio
-Piano delle prove
- Risultati delle prove
-Manuale d’uso

L’organigramma redatto dal project manager prima dell’inizio di qualsiasi attività da parte del team. Contiene le informazioni riguardati la ripartizione dei ruoli, le competenze, le conoscenze e i ruoli di ciascun membro del team. Il diario di progetto contiene tutti i movimenti, in entrata e in uscita, di tutti i prodotti o i documenti dell’archivio. Il verbale è un documento non versionato che tiene traccia degli argomenti trattati durante le varie riunioni del team. Il piano di progetto è un documento versionato redatto dal project manager per stimare risorse presenti e future, costi e tempi necessari allo sviluppo del prodotto. Le norme di progetto racchiudono invece le norme stabilite a inizio progetto entro cui si svolgono le attività del progetto. L’offerta è un documento non versionato che il project manager redige e consegna al committente che comprende descrizione, costi e tempi di consegna del prodotto. Il piano di gestione della qualità è un documento non versionato che si occupa delle politiche e degli obbiettivi della qualità. L’analisi del dominio è un documento versionato che analizza gli ambienti in cui opera il software. L’analisi dei requisiti è un documento versionato che si occupa degli obbiettivi e degli scopi del prodotto. L’architettura del software viene analizzata nel documento chiamato Specifica architetturale. Esso è affiancato dalla specifica di dettaglio che analizza i componenti individuati dalla specifica architetturale. Le prove ed i test sul prodotto sono individuati rispettivamente dai documenti Piano delle prove e Risultati delle prove. Infine, il manuale d’uso, in forma cartacea o help on-line è un documento previsto per gli utilizzatori del prodotto che analizza le azioni da eseguire al fine di utilizzare al meglio il software.

Programmazione in C con socket (parte I)

2008-10-17T18:03:00.007+02:00

1.0 Creare una socket

In questo post vedremo come scrivere programmi in C che utilizzano socket.

Affinché due socket possano comunicare è necessario che appartengono allo stesso dominio.
Esistono tre particolari domini:

PF_UNIX , dominio locale;
PF_INET, dominio internet;
PF_IPX, dominio IPX Novell;

Inoltre devono anche rispettare la medesima semantica:

SOCK_STREAM, orientata alla connessione;
SOCK_DGRAM, non orientati alla connessione;
SOCK_RDM, reliable datagram;

Ogni dominio ha un suo set ammesso di protocolli quali tcp,udp,ip,iso-tp4 ecc.
L’istruzione per creare una socket è

s = socket(...);

a breve vedremo quali sono i parametri formali.
Per assegnare un indirizzo ad un socket scriveremo:

bind(s,&myAddr,addrLen);

invece l’istruzione seguente permette di stabilire il numero di socket di cui restare in ascolto.
pendingQSize è il numero di socket.

listen(s,pendingQSize);

Con la seguente istruzione si è in grado di ascoltare la socket:

s1 = accept(s,...);

Le istruzioni viste prima permettono di lavorare con le socket dal lato server. Con una discreta simmetria è possibile farlo anche dal lato client.

t = socket(...);

Da questo momento sarà possibile connettersi con l’istruzione:

connect(t,&servrAddr,addrLen);

Entrambi i lati prevedono la chiusura della connessione con

close();

Affinché la connessione venga stabilita gli indirizzi indicati da servrAddr e myAddr devono necessariamente coincidere. Per l’apertura di una socket è necessario importare le relative librerie

#include < sys / types.h >
#include < sys / socket.h >

L’istruzione di creazione della socket vista prima può adesso essere utilizzata

int socket(int domain, int type, int protocol);

L’int restituito è -1 se è sorto qualche errore.
domain è uno dei domini visti prima, type il tipo di sematica,e protocol il protocollo da utilizzare, di default è 0.
Le socket vengono create bloccanti di default ma questa opzione può essere modificata con l’istruzione:

fcntl(s,F_SETFL,O NONBLOCK);

Il descrittore di socket ha solo valore locale. Legarla ad un indirizzo permette di renderla pubblica.

#include < sys / types.h >
#include < sys / socket.h >

int bind(int sockfd, struct sockaddr *my_addr,int addrlen);

Anche qui il valore restituito è -1 se qualcosa è andato storto. Altri valori messi sono indicati dalle costanti:

EBADF, quando sockfd non è un descrittore valido.
ENOTSOCK, sockfd è un descrittore di file e non di socket.
EINVAL, la socket è già stata assegnata ad un indirizzo.
EACCESS, l’indirizzo è protetto e l’utente non ha i relativi permessi.

Come è possibile notare l’indirizzo è un puntatore. Sarà dunque necessario implementare una struct per l’indirizzo secondo il suo dominio.

struct sockaddr
{
sa_family_t sa_family;
char sa_data[14];
};

Nel caso del dominio PF_UNIX la struct diventa

#define UNIX_PATH_MAX 108
struct sockaddr_un
{
sa_family_t sun_family;
char sun_path[UNIX_PATH_MAX];
};

Nel caso del dominio PF_INET la struct diventa

struct sockaddr_in {
sa_family_t sin_family;
u_int16_t sin_port;
struct in_addr sin_addr;
};

struct in_addr {
u_int32_t s_addr; // IPv4 address in network byte order
};

Affinché l’argomento int sockfd della chiamata bind sia compatibile con la specializzazione della struct sockaddr è necessario fare il cast di tipo con l’istruzione:

bind(sd, (struct sockaddr * ) &thisAddr, alen);

2.0 Connessione di una socket

Per connettere una socket ad un’altra socket remota si ricorre alla function connect

#include < sys / types.h >
#include < sys / socket.h >
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);

una socket sockfd di tipo SOCKET_STREAM in generale può essere oggetto di una connessione una sola volta.La function restituisce 0 di esito positivo o un int corrispondente a

EBADF, se il descrittore di socket è errato.

ENOTSOCK, se il descrittore non è associato ad una socket

EISCONN, se la socket è già connessa

ECONNREFUSED, se il server rifiuta la connessione.

ETIMEDOUT, se la connessione va in timeout

ENETUNREACH, se la rete non è disponibile

EADDRINUSE, se l’indirizzo è già in uso.

Il lato server dovrà rimanere in ascolto della connessione con

#include # <>
int listen(int s, int backlog);

se la socket è di tipo SOCK_STREAM o SOCK_SQPACKET. L’ int backlog indica la lunghezza massima della coda delle richieste di connessione. Se la coda è piena il lato client riceverà l’errore ECONNREFUSED. Se il protocollo dello strato inferiore ammette ritrasmissione la coda piena viene ignorata. Come nel lato client la funzione restituisce 0 in caso di esito positivo oppure

EBADF, se il descrittore non è valido

ENOTSOCK , come argomento non è stata passata una socket.

EOPNOTSUPP, la socket non è del tipo supportato.

Una socket di tipo SOCK_STREAM può accettare la connessione con

#include < sys / types.h >
#include < sys / socket.h >
int accept(int s, struct sockaddr *addr, int *addrlen);

La function non fa altro che estrarre la richiesta di connessione dalla coda e creare e restituire una nuova socket con le proprietà di s collegata alla relativa socket remota. Se non vi sono richieste pendenti la funzione blocca la socket se questa è di tipo bloccante altrimenti restituisce errore. Qui addr è un parametro risultato il cui formato dipende dal dominio mentre addrlen deve valere il numero di byte allocati per addr.

3.0 Lettura e scrittura.

Le operazioni di lettura e scrittura sono mostrate rispettivamente:

Lettura:

s = socket(PF_INET,SOCK_STREAM,0);
bind(s,&myAddr,sizeof(myAddr));
listen(s,maxQSize);
s1 = accept(s,&clntaddr,&addrL);
...
read(s1,inMsg,sizeof(inMsg));

Scrittura

t = socket(PF_INET,SOCK_STREAM,0);
connect(t,&servrAddr,sizeof(servrAddr));
...
write(t,outMsg,sizeof(outMsg))

Oltre alla funzione di chiusura close() vista prima è possibile effettuare la chiusura selettiva con

#include < sys / socket.h >
int shutdown(int s, int how);

dove how può assumere i seguenti valori:

0, per disabilitare ulteriori ricezioni
1,per disabilitare ulteriori invii
2, per disabilitare ulteriori invii e ricezioni

Con

read(s,buf,cnt)

è possibile leggere fino a cnt byte e restituisce 0 in caso di esito positivo altrimenti -1. In caso di lettura in mancanza di dati da una socket non bloccante verrà restituito un errore. In caso di socket bloccante se la connessione è aperta verrà bloccata ma se la connessione è chiusa può causare errore o leggere 0 byte. Scrivere su socket non più connesse restituisce errore se non viene adeguatamente gestito.

4.0 Socket senza connessione

Per scambiare dati tra socket abbiamo a disposizione due gruppi di chiamate di sistema. Il primo è costituito da sendto(…) e recvfrom(…), il secondo da send(…) e recv(…). Il secondo gruppo di chiamate di sistema prevede che le socket locali siano già connesse. Una volta creata la connessione con il tipo di socket relativo e associata quest’ultima ad un indirizzo locale è possibile inviare dati con :

>#include < sys / types.h >
#include < sys / socket.h >
int send(int s, const void *msg, int len,
unsigned int flags);

o al posto di send:

int sendto(int s, const void *msg, int len,
unsigned int flags,
const struct sockaddr *to, int tolen);

dove i primi tre parametri e flags è una costante tra

#define MSG_OOB 0x1 //si stanno inviando dati fuori-banda
#define MSG_DONTROUTE 0x4 // non controlla tabelle di routing
#define MSG_DONTWAIT 0x40 //invio non bloccante

altre costanti non verranno prese in considerazione. Gli ultimi due parametri si riferiscono alla struct relativa all’indirizzo di protocollo e alla sua lunghezza in byte. La lunghezza del messaggio puntato da *msg dipende dal protocollo sottostante. Il valore restituito sarà il numero di byte inviati o -1 in caso di errore. Per ricevere dati utilizzeremo invece:

int recv(int s, void *buf, int len, unsigned int flags);

oppure

int recvfrom(int s, void *buf, int len, unsigned int flags,
struct sockaddr *from, int *fromlen);

I parametri omonimi a quelli visti con send e sendto hanno lo stesso significato. Gli ultimi due parametri di recvfrom sono puntatori alla struct dell’indirizzo del mittente e alla sua lunghezza. Anche qui il valore restituito è il numero di byte letti o in caso di errore -1.

Introduzione allo Sviluppo di Software

2008-10-15T15:29:00.002+02:00

1.0 Introduzione

Nello sviluppo di un software, il team è costituito da diverse persone che svolgono diversi ruoli. Il leader, ha il ruolo di coordinare l’intero sviluppo del software, determinare i fattori tecnici e organizzativi, strutturare la soluzione del problema, motivare gli altri membri del team ecc. Vi sono i programmatori che hanno il compito di realizzare l’implementazione, gli analisti che si occupano della verifica e della convalida del software e così via. Il numero e il tipo di membri dipendono dal progetto che si vuole realizzare e dalle risorse economiche e professionali che si ha a disposizione.
Un progetto in ambito software gode di alcune proprietà: è un impresa svolta da più persone, che ha una durata limitata di tempo, una certa quantità di risorse a disposizione e deve essere pianificat0 e controllato costantemente al fine di garantire un buon risultato. Un progetto software è unico, ovvero affronta un problema che non era mai stato affrontato prima, temporaneo ,ovvero ha una durata limitata di tempo, ed può essere affrontato con modalità e tecniche differenti.

2.0 Tipi di progetti

I progetti possono essere racchiusi in tre principali tronconi:

Progetti nati dalla modifica di software già esistente.
Progetti nati dallo sviluppo di un software da zero.
Progetti nati dallo sviluppo di un software a partire da componenti da riutilizzare

Al fine di garantire il risultato lo sviluppo di un progetto viene affrontato mediante un processo software. Un processo software è l’insieme di operazioni che porta alla creazione alla produzione di programmi, documenti e dati come conseguenza dell’ingegneria del software definite dal processo stesso.

3.0 Processo software

La struttura di un processo software prevede due unità principali:

Attività Strutturali

Attività Ombrello

Le attività strutturali sono determinate da

Comunicazioni
Pianificazione
Modellazione
Costruzione
Dispiegamento

Le Attività ombrello sono invece determinate da

Controllo del progetto e sviluppo del software
Gestione dei rischi
Valutazione della qualità del prodotto ottenuto
Revisioni tecnico formali
Misura
Gestione del riuso

Vedremo in dettaglio ciascuna attività.

4.0 Modello Prescrittivo

Definisce un insieme di attività, azioni e compiti necessari al fine di ingegnerizzare il prodotto. Ciascun modello definisce anche un flusso di lavoro, ovvero il modo in cui gli elementi sono relazionati e godono di pregi e difetti. Alcuni esempi di modelli prescrittivi sono il modello a cascata, il modello a processo incrementale, il modello Extreme Programming ecc. Ciascuno di essi si adatta ( o non si adatta) a un tipo specifico di progetto o di team.

Modello a Cascata : detto anche ciclo di vita classico o modello sequenziale, si basa su un approccio sistematico e sequenzale. Si adatta bene quando i requisiti di un problema sono abbastanza noti, o si prevede uno sviluppo lineare. Le modifiche sono problematiche, difficilmente si conoscono e si possono esplicitare tutti i requisiti. Un programma funzionante si ottiene solitamente verso la fine dello sviluppo.

Modello a processi incrementali: si adatta bene se i requisiti iniziali sono chiari ed il progetto è molto ampio, se si preferisce fornire da subito delle funzionalità basi che vanno poi raffinate successivamente. La sequenza degli incrementi può anche essere pianificata ad hoc.

Modello Rapid Application Development: come suggerisce il nome, viene impiegato se si vuole concludere rapidamente un progetto.E' una sorta di evoluzione del modello a cascata e si adatta bene ai progetti modulari, in cui i moduli sono ben definibili e confinati.

Modello a Processo Evolutivo: adatto ai progetti in cui i requisiti variano spesso, i dettagli devono ancora essere definiti, le scadenze non sono rigide.

Modello a Spirale: si basa su prototipi e su un approccio ciclico crescendo in maniera incrementale il grado di definizione e implementazione del sistema.

Modello a processo Unificato: si basa sui casi d'uso, è iterativo ed incrementale.

Modello a processo Agile: è guidato dalle descrizioni fatte dai clienti, sviluppa in maniera iterativa, consegna frequenti incrementi software e si adatta bene ai cambiamenti. Deve essere adattato ai bisogni del team che solitamente si autoregolano.

Introduzione a MathLab

2008-10-14T19:43:00.003+02:00

1.0 Operazioni di base

Matlab è un linguaggio di programmazione e un ambiente di lavoro grafico per il calcolo scientifico con routines e functions altamente avanzate. È possibile effettuare operazioni di calcolo di base semplicemente scrivendole come in una tradizionale calcolatrice. Ad esempio:

>> 2 + 3

Si otterrà in output il relativo risultato. Se vogliamo che il risultato non venga stampato su schermo facciamo seguire l’espressione da un ;

>> 2 + 3 ;

Normalmente Matlab stampa solo le prime 4 cifre decimale ma è anche possibile cambiare tale opzione:

>> format long

ad esempio per il formato long. Per altri formati è possibile ricorrere all’help con il comando

>>help

Per avere informazioni su una particolare function si utilizza il comando

>>lookfor parola_chiave

Dove parola_chiave è la nostra chiave di ricerca.
Come in un qualsiasi linguaggio di programmazione si possono definire variabili:

>>a= 2

Per definire la variabile a. Alcune variabili sono à predefinite quali “pi” per P greco ecc.
Un vettore si può definire in diversi modi:

>> A= [ 1 2 3 4 5 6 ]

Per un vettore riga

>> A=[ 1; 2; 3; 3; 5 ]

Per un vettore colonna

>> A=[ 1; 2; 3; 3; 5 ]’

Per la trasposta di A.

>> A=[ 1 2 3;2 5 6; 5 7 9]

Per stampare la matrice

A =

1 2 3
2 5 6
5 7 9

Oppure si possono usare alcune functions come

>>A=zeros(2)

Per una matrice 2x2 nulla.

>>A=ones(2)

Per una matrice 2x2 di 1.

>>A=rand(2)

Per una matrice 2x2 di valori casuali.

Il carattere : serve per indicare un ciclo. Ad esempio il comando

>> A= 1:5

Stampa il vettore [ 1 2 3 4 5].

Le operazioni algebriche sulle matrice o sui vettori vengono eseguiti automaticamente dai relativi operatori:

>> A+B

Ad esempio stampa la somma delle matrici A e B e così via.

Altri operatori sono

/ divisione
* moltiplicazione di matrici
.* moltiplicazione di componenti
^ potenza

Gli operatori relazioni sono

= uguale
~= diverso
> maggiore
>= maggiore uguale
Ecc.

Gli operatori logici sono:

& and
or
~ not

Tutti gli operatori visti sono validi anche per le matrici.

Alcune functions utili per le matrici sono

>>diag(A)

Per stampare la sua diagonale.

>>sum(A)

Per stampare il vettore somma di A.

>>fliplr(A)

Per la matrice speculare di A.

Come in un qualunque altro linguaggio è possibile utilizzare costrutti di selezione della forma

if espressione
istruzione1
istruzione2
…
end

oppure della forma

if espressione
istruzione1
elseif espressione
istruzione2
end

Se l’espressione richiede il confronto tra stringhe esse devono anche essere della stessa lunghezza.
Ad esempio si può scrivere

If (x== ‘ciao ’)
display(‘ciao)
elseif(x== ‘salve’)
dislay(‘buongiorno’)

Come vedete, alla stringa ‘ciao’ è stato aggiunto un carattere al fine di avere la stessa lunghezza di ‘salve’. Come in tutti i comuni linguaggi è possibile utilizzare cicli iterativi della forma

for(variabile=espressione)
istruzione1
istruzione2
….
end

Ad esempio se vogliamo calcolare la somma dei primi 50 numeri scriviamo

s=0;
for i=1:50
s=s+i;
end

Anche Mathlab ammette cicli annidati. Simmetricamente, si può utilizzare il costrutto while

while( variabile=espressione)
istruzione1
istruzione2
…..
end

I programmi scritti in Mathlab hanno estensione .m . Si dividono in due categorie:

-gli script-file che non ricevono e non restituiscono valori ma operano sulle variabili del workspace

- i function-file che ricevono e restituiscono valori e le cui variabili non modificano le variabili del workspace.

I commenti sono preceduti dal carattere ‘%’. Le prime righe di commento diventano parte dell’help on-line.Una function si definisce con l’istruzione:

function [out1,out2..]= nome_funzione(in1,in2,in3)

in cui out1,out2 sono gli output e in1,in2 gli input.Il file va salvato con il nome nome_funzione.m . È possibile utilizzare meno parametri attuali rispetto ai parametri formali definiti dalla function.

Introduzione ai Sistemi Distribuiti

2008-10-13T19:49:00.003+02:00

Per sistema distribuito si intende una collezione di computer indipendenti che appare agli utenti come un singolo sistema coerente dal quale ricevere un servizio. Agli utenti è del tutto celata la tipologia di sistema,il numero di sistemi coinvolti,la modalità in cui sono interconnessi, le loro prestazioni e così via. L’obbiettivo principale di un sistema distribuito è rendere l’accesso alle risorse remote facile ed efficiente. Nel far ciò il sistema deve rispettare tre principi fondamentali: trasparenza, apertura e scalabilità, ovvero deve nascondere il meccanismo che sta dietro all’accesso alle risorse richieste dall’utente, deve rispettare tutte le regole di standard e poter offrire i servizi richiesti nel modo migliore in base,ad esempio, al tipo di servizio o al tipo di utenza. Esistono differenti tipi di architetture distribuite. Nel modello client-server, un lato chiamato server offre servizi al lato opposto detto client che li ha richiesti. Nel modello decentralizzato vi sono una serie di pari chiamati peers che richiedono e offrono servizi tra loro. Questi due modelli possono essere combinati in un modello detto ibrido. Al fine di supportare computer e reti eterogenei continuando a mantenere le proprietà viste prime i sistemi distribuiti sono spesso organizzati come uno strato di software logicamente posizionato tra gli utenti e le loro applicazioni e il sistema operativo. In questo caso si parla di middleware. Tutti i sistemi odierni, al fine di offrire servizi remoti ricorrono alle socket. Una socket è dal punto di vista logico un punto di ingresso o di uscita verso cui incanalare dati al fine di trasmetterli in rete. I sistemi devono creare e collegare dinamicamente le socket prima di utilizzarle. Un programmatore utilizza una socket come un oggetto su cui operare uno stream di dati; in questo modo ne viene celato il meccanismo di trasmissione ( vedi archivio Reti di Calcolatori).

Tavola Riassuntiva della Complessità Asintotica dei Principali Algoritmi Noti

2008-09-28T18:04:00.002+02:00

Download

Errata Corrige: nel 4 rigo la voce MergeSort va sostituita con QuickSort.

Esempi Problem Solving in Java

2008-09-17T22:12:00.000+02:00

Esempi pratici sulla tecnica di problem solving in java.

Download

Procedure e Metodi in Java

2008-09-16T22:13:00.003+02:00

Raccolta di metodi e procedure in java per la risoluzione di problemi di natura differente. Gli esempi vogliono essere una forma di allenamento alla risoluzione di problemi mediante il linguaggio Java.

Download

Esempi di Calcolo della Complessità Asintotica

2008-09-15T21:25:00.030+02:00

Esempi pratici sul calcolo della complessità asintotica suddivisi in diverse parti:

Parte 1;

Parte 2;

Parte 3;

Parte 4;

Parte 5;

Parte 6;

Parte 7;

Errata Corrige: Parte 5. Nel primo caso del teorema master la soluzione è compresa tra 1 e 3 (cambiare il 4 con il 3).

Alberi Splay e Alberi AVL

2008-09-13T21:47:00.002+02:00

Appunti in formato jpg sugli alberi AVL e sugli alberi Splay

A

2008-09-12T22:05:00.008+02:00

Accessibilità: ramo della scienza nota come "Interazione Uomo-Macchina" , che si pone l'obbiettivo di migliorare la fruizione di contenuti da parte di qualsiasi utente che ne vuole usufruire.

Albero AVL(Adelson-Velski-Landis): Particolare albero binario di ricerca in cui per ogni nodo l'altezza del sottoalbero sinistro e quello destro differiscono al più di 1 ed entrambi i sottoalberi sono a loro volta alberi AVL.

Albero Rosso-Nero (Albero RB): Particolare albero di ricerca binario in cui i nodi assumono due colori, rosso e nero ,mantenendo valide 5 proprietà: La radice è nera; tutte le foglie sono nere; tutti i nodi sono o rossi o neri, qualsiasi percorso da un nodo interno ad una foglia contiene lo stesso numero di nodi neri; se un nodo è rosso entrambi i suoi figli sono neri.

Albero Splay: particolare tipo di albero di ricerca binario i cui elementi sono ordinati per frequenza di accesso dall'alto verso il basso.

Algebra Relazionale: Insieme degli operatori,operandi e operazioni che permettono di rappresentare dal punto di vista logico le query di un database.

Applet: Nell'ambito delle tecnoligie Java per il web, un'applet è un oggetto per l'utilizzo di elementi dinamici che può essere integrato in una pagina web.

Operazioni su Alberi Rosso Neri

2008-09-12T21:53:00.002+02:00

Operazioni elementari su alberi RB con esempi pratici in formato jpg

Introduzione ai grafi

2008-08-23T21:57:00.001+02:00

Appunti introduttivi sui grafi in formato jpg.

Strutture dati elementari

2008-08-22T22:17:00.001+02:00

Presentazione delle strutture dati pile,code,stack e alberi binari di ricerca,alberi rosso-neri,alberi di intervalli in formato jpg su fileden.

Ordinamento e Statistiche d'Ordine

2008-08-20T22:00:00.002+02:00

Post su ordinamento e statistiche d'ordine in formato jpg uppato su fileden.

H

2008-08-16T21:33:00.003+02:00

Heap binario: struttura dati costituita da un array il cui comportamento dei suoi elementi corrispondi ad un albero binario. Esistono due tipi di heap binario: il max-heap, il cui albero rappresentato è un albero binario ordinato in ordine decrescente e min-heap, il cui albero è in ordine crescente.

Ricorrenze

2008-08-15T12:03:00.003+02:00

Appunti su Ricorrenze,metodo di sostituzione,metodo degli alberi di ricorrenze e metodo master con dimostrazione del teorema.

Crescita di funzioni

2008-08-13T00:18:00.002+02:00

Post sulla crescita di funzioni

Divide et impera

2008-08-11T22:24:00.001+02:00

Post su Divide et impera con analisi di merge sort in upload su fileeden

Insertion Sort

2008-08-08T16:04:00.006+02:00

Prima parte del post su insertion sort pubblicato in formato immagine su fileEden

Seconda parte del post dedicato a insertion sort

Una breve nota

2008-08-08T16:01:00.003+02:00

Gentili lettori,
per motivi legati all'implementazione dell'editor html di blogspot, molte delle notazioni utilizzate nei post non possono essere visualizzate correttamente, perciò mi vedrò costretto a pubblicare appunti scritti a mano. Cercherò di utilizzare una caligrafia quanto più chiara possibile e, rinnovando le mie scuse, colgo l'occasione per salutare tutti i miei lettori.

Introduzione agli algoritmi

2008-08-02T16:18:00.007+02:00

Il termine algoritmo può essere definito come una procedura di calcolo ben definita che prendi un valore o un insieme di valore come input e genera un valore o un insieme di valori come output. Un algoritmo è dunque una sequenza di passi computazionali che trasforma l’input in output. Possiamo considerare un algoritmo come uno strumento per risolvere un problema computazionale ben definito. Per esempio si supponga di dover ordinare una sequenza di n elementi in ordine crescente o decrescente. Il problema dell'ordinamento può formalmente essere definito nel modo seguente:

Input: una sequenza di n numeri (a1,a2,…..an )

Outuput: una permutazione (a1’,a2’,…..an‘) tale che (a1'< a2' < .... < an').

La sequenza di input viene detta istanza del problema di ordinamento. L’istanza del problema è l’input che soddisfa tutti i vincoli imposti dalla definizione del problema richiesto per calcolare una soluzione del problema. Un algoritmo è corretto se per ogni istanza di input termina con l’output corretto. In questo caso l’algoritmo risolve il problema computazionale dato. Gli algoritmi devono essere efficienti, ovvero devono utilizzare il minor numero di risorse possibile in termini di tempo e di spazio. Anche se ci occuperemo principalmente di soli algoritmi corretti, un algoritmo non corretto può essere utilizzato ugualmente se il suo margine di errore è nei limiti di tolleranza. Ci occuperemo in altre occasioni degli algoritmi non corretti.

0-9

2008-07-20T15:51:00.003+02:00

4B/5B ( Codifica): codifica che consiste in output di 5 bit a partire da 4 bit. Le codeword non utilizzate per i dati vengono impiegate con la funzione di controllo.

8B/6T (Codifica): codifica che consiste in output di 6 trit a partire da 8 bit.

Il protocollo HDLC (High-Level Data Link Control)

2008-07-07T21:41:00.010+02:00

Il protocollo HDL nasce da un protocollo usato in principio nell'ambiente dei mainframe IBM, chiamato SDLC, che dopo alcune modifiche divenne starndard ANSI con il nome ADCCP. Analogamente SDLC divenne standard ISO con il nome HDLC. Tutti questi protocolli si assomigliano per la maggior parte delle loro caratteristiche ma differiscono in alcuni punti. Utilizzano frame di 6 campi, uno Address, che indica l'indirizzo del terminale,uno Control che vedremo più avanti, uno Data che contiene il carico utile e può avere lunghezza variabile, il campo Chechsum per la codifica a controllo d'errore a ridondanza ciclica (CRC), il tutto delimitato dalla sequenza 01111110. I frame possono essere di tre tipi: informazione, supervisione e senza numero. Il campo Control differisce per ogni tipo di frame.Questo campo contiene i seguenti sotto-campi: il campo Seq indica il numero di sequenza e si possono avere fino a 7 frame in attesa di ack. Il campo Next è usato per il piggyback dell'ack ovvero nel trasporto dell'ack dell'ultimo frame ricevuto (in verità questi protocolli usano il piggybacking per l'ack del successivo frame non ancora ricevuto e non dell'ultimo frame ricevuto). Il campo P/F è usato quando un computer vuole interrogare un gruppo di terminali. Se usato come Poll invita il terminale a mandare dati. Tutti i frame inviati dal computer avranno questo bit impostato a P mentre l'ultimo lo imposterà a F. Il bit P/F è usato a volte per forzare l'altra macchina a inviare immediatamente un frame supervisione. In alcuni casi questo campo è usato in connessione con i frame senza numero. I frame supervisione si distinguono dal frame informazione in quanto usano il campo Type al posto del campo Seq. Se Type è di tipo 0 il frame è un frame di acknoledgement (ufficialmente chiamato RECEIVE READY); se è di tipo 1 è un frame di anacknoledgment (chiamato REJECT); se è di tipo 2 (RECEIVE NOT READY) è usato per ricevere gli ack di tutti i frame fino a ,ma non incluso, quello indicato da Next. Il terzo tipo è chiamato SELECTIVE REJECT e chiede esclusivamente la trasmissione del frame specificato. Il terzo tipo è presente solo nei protocolli HDLC e ADCCP. La terza e ultima classe di frame è il tipo senza numero. Può essere impiegato per informazioni di controllo o per trasportare solo dati per conto di servizi senza connessione e non affidabili. Per indicare il tipo di frame sono presenti 5 bit ma non sono usate tutte le 32 combinazioni. Ad esempio tutti i protocolli usano il tipo DISC, che permette di annunciare che si sta andando fuori linea e si può tornare operativi con il comando SNRM. SNRM purtroppo è asincronico in quanto legato alle vecchie comunicazioni che venivano fatte da terminali stupidi che colloquiavano con l'elaboratore centrale. Per rendere il protocollo più appropriato furono introdotti i comandi SABME e SNRME per ovviare al problema. Un ulteriore tipo è chiamato FRMR ed è impiegato per indicare l'arrivo di un frame con il checksum corretto ma con una semantica impossibile. Esiste anche uno speciale frame di controllo chiamato UA che contiene acknolegment. Oltre all'UA ve ne sono altri adibiti ad esempio ad operazioni di inizializzazione, interrogazione, di rapporto sullo stato e di informazioni. Questi frame non passano al livello di rete ma sono solamente per lo strato data link. Ecco una sintesi che riassume il contenuto dei frame.

Il Protocollo PPP(Point to Point Protocol)

2008-07-06T22:08:00.007+02:00

Il protocollo PPP (Point to Point Protocol) è il protocollo a livello datalink più utilizzato oggi soprattutto nel dialogo tra privati e ISP. Soffermiamoci un attimo sui requisiti stabiliti da IETF per il suo progetto.

Framing dei Pacchetti:il protocollo deve essere in grado di frammentare i pacchetti in moda da consentire al ricevente l'individuamento dell'inizio e della fine di ogni pacchetto a livello link e di rete.

Trasparenza: Il protocollo non deve porre alcuna restrizione ai dati che appaiono a livello di rete.

Protocolli Multipli del livello di Rete: deve supportare i vari protocolli a livello di rete e multiplexare diversi protocolli del livello di rete su una connessione punto a punto.

Tipi di Link multipli: il protocollo deve supportare una vasta tipologia di collegamenti quali seriali, paralleli,sincroni,asincroni,a bassa o alta velocità.

Rilevazione degli errori: il ricevente deve essere in grado di rilevare errori nei pacchetti.

Disponibilità della connessione: il protocollo deve rilevare la presenza di eventuali guasti a livello di link e segnararli.

Negoziazione degli indirizzi di rete: PPP deve essere in grado di ottenere e configurare gli indirizzi di rete.

Semplicità: la parola d'ordine per un protocollo punto a punto è semplicità.

Controllo di flusso: il protocollo deve essere di gestire il traffico di pacchetti in base al tasso nominale del sottostante livello fisico.

Sequenza: i pacchetti non devono essere necessariamente trasferiti al ricevente nello stesso ordine in cui sono spediti dal trasmittente.

Collegamento multipunto: PPP può operare solo su collegamenti punto a punto.

Analizziamo le caratteristiche salienti di questo protocollo. Ecco come PPP frammenta i dati:

Flag: Ogni pacchetto PPP inizia e termina con la sequenza 01111110.

Indirizzo: L'unico valore di questo campo è 11111111.

Controllo: L'unico valore di questo campo è 00000011. Questi due campi hanno valori fissi in quanto ulteriori valori potrebbero essere stabiliti più avanti se richiesto.

Protocollo: Questo campo indica al ricevente quale è il protocollo del livello superiore a cui appartengono i dati incapsulati.

Informazioni:Questo campo include il pacchetto trasmesso dal livello superiore. La sua lunghezza solitamente è 1500 byte ma può essere variata quando si configurara per la prima volta un pacchetto.

CheckSum: PPP prevede un sistema di codifica a rilevazione di errori a ridondanza ciclica CRC a due o quattro byte.

Per il framing dei dati PPP ricorre al byte stuffing in accordo al principio di trasparenza visto prima. In pratica quando si presenta una sequenza di dati simile all'intestazione, PPP premette un byte di controllo per indicare che si tratta di un dato reale. Il ricevente provvederà a rimuovere il byte di controllo e a ricostruire la sequenza originale. Vediamo adesso come si configura un collegamento PPP. I due peer prima di trasmettere dati eseguono una sorta di handshake a tre vie. Nel momento in cui si verifica un evento come la rilevazione della portante o l'intervento dell'amministratore di rete, PPP entra nello stato di configurazione del collegamento. Un lato del collegamento invia un pacchetto configure-request LCP, in cui LCP è l'omonimo protocollo di controllo del collegamento (Link Control Protocol). L'altro lato può accettare tutte le opzioni con un pacchetto configure-ack, rifituarle con un pacchetto configure-nack o potrebbe non identificarle e quindi non accettarle con un pacchetto configure-reject. Le opzioni di configurazione prevedono la dimensione massima del pacchetto, la specifica di un protocollo di identificazione e un'opzione per l'omissione dei campi indirizzo e controllo dei pacchetti. Se sopra PPP c'è IP è possibile configurare i moduli di IP utilizzando il protocollo di controllo IP IPCP. I dati IPCP vengono inseriti in un pacchetto PPP in modo analogo a quello in cui sono inseriti i dati LCP. A questo punto i due estremi del collegamento possono iniziare lo scambio di dati. Il collegamento PPP rimane configurato finchè un'estremità invia un pacchetto LCP di richiesta chiusura e ottiene un pacchetto LCP di riscontro. A questo punto il collegamento entra nello stato di inattività.

Modelli di Riferimento

2008-07-02T15:30:00.006+02:00

Le reti presentano sempre una struttura complessa e profonda. Essa è organizzata come una pila o un insieme di livelli ciascuno dei quali costituisce uno strumento per offrire determinati servizi al livello superiore, schermandoli dall'implementazione. Le regole e le convezioni utilizzate a questo scopo sono note come protocolli. E' utile fare una distinzione tra protocollo e servizio. Un servizio è un insieme di primitive (operazioni) che uno strato offre ad uno strato superiore. Un protocollo è un insieme di regole che controllano il significato ed il formato dei pacchetti o dei messaggi scambiati tra le entità pari all'interno di uno strato (cioè i rispettivi livelli). Ogni architettura di rete presenta una sua pila di protocolli,un certo numero di strati con un certo numero di protocolli e servizi per ognuno di essi. I due esempi più importanti sono il modello OSI e il modello TCP/IP. Il modello OSI presenta 7 strati: lo strato fisico che si occupa della trasmissione dei bit grezzi sul canale di comunicazione, lo strato data-link che consiste nel rilevare gli errori di trasmisisone, lo strato di rete che controlla il funzionamento della subnet, lo strato trasporto che si occupa di frammentare e assicurare allo strato di rete tutti i pacchetti dello strato superiore in ordine corretto, lo strato sessione che si occupa di stabilire da due utenti su computer diversi una sessione, lo strato presentazione che si occupa della sintassi e delle semantica dell'informazione trasmessa, e lo strato applicazione che comprende i protocolli comunemente richiesti dagli utenti per le applicazioni. Il modello TCP/IP comprende 5 strati, lo strato fisico,data-link,rete,trasporto, applicazione che svolgono grosso modo le analoghe funzioni del modello OSI. Sostanzialmente il modello OSI nacque per lo più per offrire un modello di riferimento a cui le implementazioni sussessive avrebbero dovuto puntare, in quanto fu concepito prima ancora dei protocolli corrispondenti e ciò lo rende generico e di scarsa applicazione. Il modello TCP/IP invece nacque dopo la realizzazione dei suoi protocolli ai quali fu "incastrato" il modello OSI. Per questo motivo il modello TCP/IP presenta strati in cui servizi e protocolli spesso sono difficilmente distinguibili ed è poco adatto a descrivere architetture differenti da TCP/IP stesso. Per tutto il corso dei posts di questo archivio utilizzeremo il modello TCP/IP.

Fondamenti di UNIX

2008-06-26T15:32:00.014+02:00

Fino agli anni ’60 il teatro dell’informatica era dominato da enormi mainframe dal valore commerciale di milioni di dollari, muniti di SO poco efficienti e di dimensioni elevate. Alla fine degli anni ’60 il mercato dei minicomputer cominciò prepotentemente a farsi largo per via delle moderate prestazioni e dei costi contenuti. In questo contesto si inserisce un piccolo sistema operativo ideato da Khen Thompson e scritto inizialmente in assembler e poi in C. Unix è distribuito in diverse versioni e in versione standard chiamata POSIX. La versione di cui ci occuperemo è Linux.

Comandi di Base

Questo post vuole solo essere una guida ai comandi basilari del sistema Unix, ovvero ai comandi per il login, di operazione con i file e le directory ed i fondamenti di creazione di shell scripts. Affronteremo i concetti avanzati in post successivi.

La prima operazione di cui ci occuperemo sarà il Login. Inseriremo dunque la nostra user-id e la password. A questo punto la shell, un programma con il compito di ricevere i nostri comandi, è in attesa e vedremo il prompt. Alcune combinazioni di tasti possono avere effetti sul programma in esecuzione o sulla shell.

Ctrl-C interrompe l’esecuzione di un programma;
Ctrl-S blocca su schermo l’output;
Ctrl-Q riprende su schermo l’output;

Possiamo cambiare la nostra password tramite il comando $passwd e seguire le istruzioni su schermo. Notate che il simbolo $ indica che segue un comando da inserire in shell e sarà il simbolo che utlizzeremo da questo momento in poi. Per terminare la nostra sessione utilizzeremo uno tra i comandi $exit o $logout. Unix vede i file come una sequenza di byte e distingue tra maiuscole e minuscole (case sensitive). Se ad esempio vogliamo aggiungere una stringa al nostro file di nome appunti la stringa “oggi lezione” digiteremo $echo oggi lezione > appunti. Se vogliamo stampare su schermo il contenuto di appunti scriveremo $cat appunti. Il comando cat interpreta i byte come caratteri. Le directory servono per racchiudere file o altre directory. Ogni utente ha una home directory. Tutte le directory sono contenute in una directory chiamata root e che viene indicata con /. Per accedere ad una directory dovremmo attraversare il suo path.Unix distingue un pathname assoluto,che localizza una directory a partire dalla root e un pathname relativo che localizza un directory a partire dalla posizione corrente. Se vogliamo spostarci nella cartella Documenti contenuta in MarioRossi che si trova nella root scriveremo:

$cd MarioRossi/Documenti

Il comando $cd senza parametri ci riporta alla home directory. Se vogliamo la lista di file contenuta nella cartella documenti ci sposteremo al suo interno e scriveremo $ls. $ls ammette anche parametri quali

-a elenca anche i file
-s elenca in ordine crescente
-t elenca a partire dal più recente

e così via.
Se vogliamo vedere la struttura gerarchica della directory corrente utilizzeremo $ls con il paramentro –R come nell’esempio:

$lis –R

Possiamo usare i caratteri jolly ‘?’ per indicare un qualsiasi carattere e ‘*’ per indicare un numero imprecisato di caratteri. Ad esempio se vogliamo mostrare tutti i file che iniziano per doc scriveremo:

&ls doc*

Il carattere . e il carattere .. indicano rispettivamente la directory corrente e la directory genitore.
Il comando $mhdir nome_directory crea una nuova directory mentre il comando $rmdir nome_directory cancella la directory se questa è vuota. Il comando $cp file1 file2 d copia e sovrascrive se presenti i file file1 e file2 nella directory d. Invece $cp file1 file2 crea una copia di file1 con il nome file2.Si può anche usare il parametro –r per copiare un directory con tutte le sottodirectory. Con il comando $mv f1 f2 dir si spostano i file f1 e f2 all’interno di dir e si sovrascrivono se già presenti oppure con il comando $mv f1 f2 si può rinominare il file f1 in f2. Ecco le combinazioni dei comandi mv e cp:

img 1.0 Il comando $mv e $cp.

I file e le directory possono essere eliminati con il comando $ rm al quale può essere associato il parametro –r per rimuovere eventuali sub directory.L’output di un comando si può ridirigere su un file tramite l’aggiunta del parametro > f alla fine del comando. L’output si può anche appendere ad un file tramite il parametro >>F. Allo stesso modo si può leggere un comando da un file tramite il parametro <>.Questi parametri possono anche essere combinati. Vi sono casi in cui l’output di un processo diventa input di un altro processo. In questi casi si crea una successione di comandi detta pipeline. L’operatore di pipeline è si pone al centro tra due comandi come nell’esempio:

$ ls -R grep ra wc –1

In questo caso però l’unico output che si ottiene è quello dell’ultimo commando. Gli output degli altri comandi si possono comunque scrivere su file interponendo tee nome_file dopo il comando come nell’esempio:

$ ls -C tee g wc –w

I comandi si possono anche comporre utilizzando ; e ponendolo al centro di essi. Si ricorda che l’operatore ha precedenza su ; e quindi vanno usate le parentesi per stabilire la priorità tra gli operatori proprio come in aritmetica. Alla fine di un comando si può inserire il terminatore & se si vuole che questo proceda in background e il prompt sia pronto prima che esso finisca. Unix ammette anche comandi per il controllo diretto dei processi:

exec cmd: termina il processo corrente per avviare cmd;
kill process-id: termina il processo process-id;
nice comando: abbassa la priorità di esecuzione di comando;
ps: mostra i processi associati al terminale da cui è invocato, mostrando per ogni processo il suo process-id e il comando in esecuzione;

I caratteri di jolly visti in precedenza ed altri caratteri hanno significato speciale per la shell (sono chiamati metacaratteri). Se si vuole che uno di questi caratteri perdi il suo significato speciale la stringa che lo include va inserita all’interno di apici.In questo modo il comando $ ls ‘a*’ ad esempio stamperà a schermo il contenuto di a*. Si può anteporre anche / prima del metacarattere. Se utilizziamo spesso comandi troppo lunghi o pipeline possiamo scriverli su un file di testo f e renderlo eseguibile con

$chmod +x f

Ora f sarà un comando equivalente al comando scritto sull’omonimo file. Se si chiede di eseguire un file di testo, la shell genera un processo che a sua volta esegue una copia della shell detta subshell.Questa copia esegue i comandi contenuti del file di testo che viene chiamato script di shell. Supponiamo di voler abbreviare il comando $chmod +x f visto prima creando uno script. Scriveremo allora:

$ echo ‘chmod +x $1’ >cx
$ chmod +x cx

Se si invoca cx con un argomento la subshell sostituirà $1 con l’argomento. Se vogliamo indicare un numero imprecisato di parametri utilizzeremo $*. Tali parametri non possono essere modificati da un programma di shell. Una shell può anche definire variabili tramite una stringa e assegnargli un valore tramite l’operatore = con un semplice comando.

$ aff=/home/user1/affari

È un esempio di definizione di variabile.D’ora in poi $aff si può usare al posto del suo valore. Le variabili sono private alla shell che le ha definite ma posso essere esportate.In Unix ogni file ha un descrittore chiamato i-node (consultare post dedicato ai file-system).Per localizzare i file bisogna dunque accedere al suoi i-node. Ogni directory è un file che contiene un “elemento” si 16 byte per ogni file che contiene, dei quali 16 sono per il nome semplice del file e 2 per il numero di i-node (i-number) che permette di accedere all’i-node. Un file può avere due nomi e avranno lo stesso i-node in modo da garantire un collegamento al file.Il comando da utilizzare è $ln sorgente destinazione.Questa strategia viene chiamata linking oridinario.Una alternativa viene chiamata linking simbolico, fondato su un nuovo tipo di file (link) il cui nome memorizzato permette di accedere all’i-node del file a cui si collega. Il comando per creare un link simbolico è $ln –s sorgente destinazione.

C, strutture dati

2008-06-19T22:36:00.003+02:00

Strutture dati quali lista, lista ordinata,coda,coda circolare,stack implementate in C.

Download

Fondamenti del Linguaggio C Terza Parte

2008-06-11T22:57:00.008+02:00

C supporta soltanto alcune funzioni di base per operare con i file. Non ammette il concetto di record né di chiave di ricerca e consente di operare solamente su file costituiti da sequenze lineari di byte. La prima cosa da fare per lavorare sui file è aprire il file richiesto attraverso

#include <>
main()
{
FILE *un_file;
fp= fopen( “nome_file”, operazione);
}

*un_file è il puntatore che ci permetterà di accedere al nostro file, nome_file è il nome del file sul quale stiamo lavorando, mentre operazione assume uno dei seguenti valori:

“r”: sola lettura. Sarà l’unica operazione effettuabile sul file e restituisce null se il file non esiste.
“w”: sola scrittura.Ammette questa unica operazione. Se il file non esiste verrà creato, se esiste sarà annullato il suo contenuto e ricreato.
“r+” :lettura e scrittura. Se il file non esiste ritorna null.
“w+”: scrittura e lettura.Se il file non esiste verrà creato altrimenti verrà annullato e ricreato.
“a”:append. Sarà possibile solo scrivere dati alla fine del file. Se non esiste il file verrà creato.
“a+”: lettura e append. Sarà possibile solo leggere e aggiungere dati a fine file. Se il file non esiste sarà creato altrimenti i dati verranno aggiunti a fine file.

La funzione per leggere byte da un file è:

fread( buf, dimensione,elementi, fp)

dove buf è il vettore dove devono essere trasferite le informazioni lette dal file, dimensione rappresenta la dimensione in byte di un elemento del vettore, elementi indica il numero di elementi del vettore e fp è il puntatore al file da leggere. Questa funzione ritorna il numero di elementi letti dal file che può non coincidere con il numero di elementi del vettore buf se il file è vuoto o contiene un numero di elementi a lui inferiore. Se restituisce un numero negativo vi è qualche errore. Quando viene fatta una lettura il puntatore si sposta all’ultimo elemento letto e quando termina il file ritorna all’inizio. La funzione per scrivere su un file è analoga ad fread ed è

fwrite( buf, dimensione,elementi, fp)

ed i parametri hanno lo stesso significato di quelli visti per la lettura ma con l’utilizzo per la scrittura. Una volta termine tutte le operazioni sul file questo va chiuso con l’istruzione fclose(fp); dove fp è il puntatore al file. È possibile anche muovere il puntatore per mezzo della funzione fseek(fp,n,mode); dove fp è il puntaotre al file, n indica di quanti byte il puntatore va spostato e se è negativo indica lo spostamento all’indietro, mode invece può assumere tre valori: Se vale 0 il puntatore comincia a spostarsi dall’inizio del file, 1 dalla posizione corrente e 2 dalla fine del file. fseek ritorna un numero negativo se qualcosa non è andato per il verso giusto altrimenti un numero maggiore o uguale a 0. La funzione ftell(fp); prende come parametro il puntatore al file e restituisce la posizione attuale del puntatore. C presenta anche due funzioni per la lettura e la scrittura formattata. Per la scrittura si utilizza fprintf (fp, formato, i); dove fp è il puntatore al file, formato è il formato da utilizzare ed i il valore da scrivere. In modo analogo si utilizza per la lettura fscanf(fp,formato,&i); . C permette anche di leggere una sequenza di caratteri fino al momento in cui si incontra il carattere ‘\n’. Per la lettura si utilizza la funzione fgets( buf,n,fp); dove buf rappresenta il vettore in cui la riga deve essere trasferita, n la sua dimensione ed fp il puntatore al file. Se l’operazione va a buon fine ritorna l’indirizzo di buf altrimenti ritorna null. La funzione fputs(buf,fp); scrive una riga in un file. buf ed fp hanno lo stesso significato dei corrispondenti nella funzione fgets. La funzione fgetc(fp); legge un singolo carattere da file mentre fputc(c,fp); scrive su file il carattere c. Se vogliamo sapere se il puntatore si trova a fine file possiamo ricorrere alla funzione feof(fp); che ritorna 1 in caso affermativo e 0 in caso negativo. Molte di queste operazioni che abbiamo visto lavorano in modalità buffer, ovvero non scrivono dati direttamente su disco ma temporaneamente in memoria centrale. Se vogliamo scaricare dalla memoria tutto il buffer possiamo utilizzare la funzione fflush(fp,); mentre se vogliamo disabilitare il buffer utilizziamo setbuf(fp,null); .

Per scrivere software in grado di controllare dispositivi fisici è necessario disporre di operatori sui singoli bit. C dispone di questi operatori chiamati bitwise e sono:

& AND bit a bit
OR bit a bit
^ OR esclusivo
<< Shif a destra
~ complemento a 1

Gli operatori bitwise lavorano esclusivamente su char e interi. I tipi fondamentali in C possono essere convertiti in altri tipi per rendere conformi i tipi di due operandi se questi non sono omogenei. Esistono due tipi di conversioni: implicite ed esplicite o meglio detto “cast”. Lo schema di conversione utilizzato è chiamato conversione aritmetica normale e viene descritto dalle seguenti regole:

1) Char,short int ->int
2) Float-> double
3) Char->int,short int,long int, double
4) Int-> char, short int, long int. La conversion ad un intero più corto provoca il troncamento dei bit più significativi.
5) Short int, long int ->int .Come nel punto 4.

La conversione esplicita può essere richiamata per mezzo della sintassi (nomeTipo) espressione. Oltre ai tipi fondamentali è possibile ricorrere a tipi derivati definiti dall’utente come visto in precedente. Un tipo di dato derivato in C è union e definisce una un’insieme di membri che in memoria hanno uno stesso indirizzo e vanno a occupare le medesime locazioni di memoria. Per definire una union si utilizza la sintassi

union nomeUnion{ tipoMembro nomeMembro1;
….
tipoMembro nomeMembro2; };

Analizziamo adesso le strutture dati in C. Una lista lineare è una successione di elementi omogenei che occupano in memoria una posizione qualsiasi. Ogni elemento contiene una informazione e un puntatore all’elemento successivo; il primo lo indicheremo con inf, il secondo con pun. Con punLista indicheremo il puntatore al primo elemento della lista. L’ultimo elemento della lista, ovviamente, punterà a NULL. inf può essere di tipo qualsiasi ma in questo esempio lo considereremo un intero. Per gestire la lista dovremmo essere in grado di effettuare tre operazioni: creazione della lista, inserimento e visita. La creazione della lista deve ritornare al main il puntatore al primo elemento. Tale funzione creaLista() deve comprendere la dichiarazione di un puntatore p alla testa della lista e di paus, puntatore ausiliario che useremo per creare elementi successivi al primo senza perdere il puntatore iniziale alla lista. Utilizzeremo le funzione malloc e sizeof per allocare dinamicamente la memoria occupata da un elemento. Malloc verrà poi trasformato in un puntatore per puntare allo spazio allocato. La visita può essere implementata come una stampa su schermo di tutti gli elementi presenti in lista. Nell’archivio Softpedia è possibile scaricare un’implementazione sì fatta della lista. Una pila (o stack) è una struttura dati in cui è possibile inserire e prelevare elementi esclusivamente da un estremo. Le uniche operazioni effettuabili sono push (inserimento) e pop (prelievo con eliminazione dell’elemento) e si compiono alla cima dello stack. Questo genere di strutture dati viene chiamato LIFO (Last in, First out). Altre operazioni effettuabili sulla pila sono stabilire se è piena o vuota e stamparne il contenuto. Nella categoria softpedia è possibile leggere il codice relativo a questa struttura dati.Una coda, è una struttura dati simile alla lista in cui è possibile inserire elementi sia all’inizio , sia alla fine. Possiede, dunque, due puntatori uno alla coda, uno alla testa. Una variante di questa struttura,chiamata coda circolare ha la testa come elemento successivo alla coda,e la coda come elemento precedente alla testa. Ricordiamo inoltre che l’inserimento degli elementi in queste strutture dati può avvenire in ordine. Troverete le implementazioni di queste strutture dati nell’archivio citato in precedenza.