Skillbook Logo
foto profilo

Tutte le categorie


Dal 14 settembre seguici in live streaming sul nostro canale YouTube

Gino Visciano | Skill Factory - 06/09/2020 09:53:18 | in Home

Dal 14 settembre puoi seguire le nostre attività, sia in live streaming, sia on demand, collegandoti al canale Skill Factory, su YouTube.

Anche se studi o lavori, guardando i nostri corsi di alfabetizzazione, formazione, aggiornamento e specializzazione, puoi acquisire tutte le competenze Informatica che ti servono per la scuola, per l'università, per entrare nel mondo del lavoro o per crescere professionalmente.

Seguendo le attività di informazione e le rubriche, puoi conoscere le news e tutto quello che accade nel mondo dell'Information Technology

Per essere sempre aggiornato sulle nostre attività, e non perderti nulla, iscriviti subito al canale.

Come iscriverti al nostro canale YOUTUBE! 

Per iscriverti al nostro canale devi essere in possesso di un account Google, se non hai ancora un account clicca qui.

Se sei già in possesso di un account Google, prosegui nel modo seguente:

1) Collegati al tuo account Gmail
2) Vai sul sito ufficiale di YouTube
3) Cliccare su Accedi
4) Inserisci user e password del tuo account Google
5) Clicca sul pulsante seguente:

6) Per iscriverti clicca sul pulsante indicato

7) Non dimenticare di attivare le notifiche

Arrivederci a presto!!!

 

 

Share Button

TypeScript - Lezione 7: Paradigma Object Oriented (seconda parte)

Gino Visciano | Skill Factory - 07/08/2020 22:54:12 | in Tutorials

Nella lezione precedente abbiamo introdotto il "Paradigma Object Oriented", descrivendo le seguenti proprietà di programmazione:

1) Incapsulamento;
2) Ereditarietà;
3) Polimorfismo dei metodi.

In questa lezione completiamo le proprietà di programmazione parlando di "Polimorfismo degli oggetti", la proprietà che ci permette di sfruttare le potenzialità offerte dall'Upcasting, successivamente vediamo le proprietà architetturali per creare applicazioni riusabili , scalabili e manutenibili.  

POLIMORFISMO DEGLI OGGETTI

Gli oggetti sono Polimorfi se sono simili, due oggetti possono diventare simili per ereditarietà oppure se implementano la stessa interfaccia.

Il Diagramma di classe seguente descrive un esempio di polimorfismo per erditarietà:

La classe Dirigente è la più specializzata, perché contiene maggiori responsabilità e caratteristiche, quindi è più dettagliata, mentre la classe Object è la più generica.

Tutti gli oggetti istanziati con uno dei tipi indicati nel diagramma sono simili, perché appartengono alla stessa gerarchia di ereditarietà.

Quando gli oggetti sono simili è possibile applicare l'upcasting, che permette di  assegnare ad una variabile di tipo  più generico il riferimento di un oggetto più dettagliato, come mostra l'esempio seguente:

var persona:Persona; // Variabile più generica di tipo Persona
persona=new Dipendente() // Upcasting. Il riferimento dell'oggetto di tipo Dipendente, più dettagliato, viene assegnato ad una variabile più generica di tpo Persona

L'Upcasting è utile  perché con questa tecnica è possibile passare alla stesso metodo oggetti di tipo diverso, purché simili tra loro, come mostra l'esempio seguente:

Esempio 1

 
class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getLuogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public toString():string{
        let optionsIntl.DateTimeFormatOptions = {
            day: "numeric"month: "numeric"year: "numeric"
        };
 
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB"options)+","+this.luogoDiNascita+","+this.sesso;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string){
            this.id=id;
            this.nome=nome;
            this.cognome=cognome;
            this.dataDiNascita=dataDinascita;
            this.luogoDiNascita=luogoDiNascita;
            this.sesso=sesso;
        }    
}
 
class Dipendente extends Persona {
    private ruolo:string;
    private stipendio:number;
    public setRuolo(ruolo:string):void{
        this.ruolo=ruolo;
    }
    public getRuolo():string{
        return this.ruolo;
    }
    public setStipendio(stipendio:number):void{
        this.stipendio=stipendio;
    }
    public getStipendio():number{
        return this.stipendio;
    }
    public toString():string{
        return super.toString()+","+this.ruolo+","+this.stipendio;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
            // Sovraccarico del costruttore
            public constructor();
            public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string,ruolo:string,stipendo:number);
            public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,ruolo?:string,stipendo?:number){
                super(id,nome,cognome,dataDinascita,luogoDiNascita,sesso); 
                this.ruolo=ruolo;
                this.stipendio=stipendo;
            }      
}
class Vista {
public stampa(persona:Persona){
    console.log(persona.toString())
    }    
public stampaScheda(persona:Persona){
    let optionsIntl.DateTimeFormatOptions = {
        day: "numeric"month: "numeric"year: "numeric"
    };
    console.log("Id:"+persona.getId());
    console.log("Nome:"+persona.getNome());
    console.log("Cognome:"+persona.getCognome());
    console.log("Data di nascita:"+persona.getDataDiNascita().toLocaleDateString("en-GB"options));
    console.log("Luogo di nascita:"+persona.getLuogoDiNascita());
    console.log("Sesso:"+persona.getSesso());
    // Se la variabile persona è un riferimento di tipo dipendente visualizza anche ruolo e stipendio
    if(persona instanceof Dipendente){
        console.log("Ruolo:"+persona.getRuolo());
        console.log("Stipendio:"+persona.getStipendio());
    }
    }
}
// Istanza di un oggetto di tipo Vista (view), per stampare gli oggetti simili di tipo Persona e Dipendente (model) 
var vista=new Vista();
// Istanzio due oggetti di tipo Persona (model)
var personaUno=new Persona();
var personaDue=new Persona(2,"Carla","Verdi",new Date("10/05/1992"),"Milano","F");
// Istanzio due oggetti di tipo Dipendente (model)
var dipendenteUno=new Dipendente();
var dipendenteDue=new Dipendente(4,"Paolo","Formisano",new Date("09/02/1970"),"Potenza","M","Commerciale",1800.00);
personaUno.setId(1);
personaUno.setNome("Roberta");
personaUno.setCognome("Bianchi");
personaUno.setDataDiNascita(new Date("09/07/2000"));
personaUno.setLuogDiNascita("Firenze");
personaUno.setSesso("F");
dipendenteUno.setId(3);
dipendenteUno.setNome("Michele");
dipendenteUno.setCognome("Rossi");
dipendenteUno.setDataDiNascita(new Date("08/03/1980"));
dipendenteUno.setLuogDiNascita("Torino");
dipendenteUno.setSesso("M");
dipendenteUno.setRuolo("Project Managaer");
dipendenteUno.setStipendio(1500.00);
console.log("------ Persone stampa orizzontale ------")
vista.stampa(personaUno);
console.log("---------------------------------------")
vista.stampa(personaDue);
console.log("\n------ Dipendenti stampa orizzontale ------")
vista.stampa(dipendenteUno);
console.log("--------------------------------------")
vista.stampa(dipendenteDue);
console.log("\n------ Persone stampa scheda ------")
vista.stampaScheda(personaUno);
console.log("--------------------------------")
vista.stampaScheda(personaDue);
console.log("\n------ Dipendenti stampa scheda ------")
vista.stampaScheda(dipendenteUno);
console.log("--------------------------------")
vista.stampaScheda(dipendenteDue);
 
---------------------------------------------------------------------------------------

------ Persone stampa orizzontale ------
1,Roberta,Bianchi,9/7/2000,Firenze,F
---------------------------------------
2,Carla,Verdi,10/5/1992,Milano,F

------ Dipendenti stampa orizzontale ------
3,Michele,Rossi,8/3/1980,Torino,M,Project Managaer,1500
--------------------------------------
4,Paolo,Formisano,9/2/1970,Potenza,M,Commerciale,1800

------ Persone stampa scheda ------
Id:1
Nome:Roberta
Cognome:Bianchi
Data di nascita:9/7/2000
Luogo di nascita:Firenze
Sesso:F
--------------------------------
Id:2
Nome:Carla
Cognome:Verdi
Data di nascita:10/5/1992
Luogo di nascita:Milano
Sesso:F

------ Dipendenti stampa scheda ------
Id:3
Nome:Michele
Cognome:Rossi
Data di nascita:8/3/1980
Luogo di nascita:Torino
Sesso:M
Ruolo:Project Managaer
Stipendio:1500
--------------------------------
Id:4
Nome:Paolo
Cognome:Formisano
Data di nascita:9/2/1970
Luogo di nascita:Potenza
Sesso:M
Ruolo:Commerciale
Stipendio:1800

 

 

Gli oggetti possono diventare simili, anche se implementano la stessa interfaccia, iDiagramma di classe seguente descrive un esempio di polimorfismo per interfaccia:
 

In questo caso l'Upcasting si può applicare utilizzando come tipo l'interfaccia, come mostra l'esempio seguente:

var cerchio:IFiguraGeometrica;
var rettangolo:IFiguraGeometrica;
cerchio=new Cerchio();
rettangolo=new Rettangolo(); 

Esempio 2

//geometria.ts
interface IFiguraGeometrica{
    getTipoFigura():string;
    getPerimetro():number;
    getArea():number;
}
 
class Cerchio implements IFiguraGeometrica{
    public constructor(private raggio:number){}
    public getTipoFigura():string{
        return "Cerchio";
    }
    public getPerimetro(): number {
        return 2*Math.PI*this.raggio;
    }
    public getArea(): number {
        return Math.pow(this.raggio,2)*Math.PI;
    }
}
 
class Quadrato implements IFiguraGeometrica{
    public constructor(private latoA:number){}
    public getTipoFigura():string{
        return "Quadrato";
    }
    public getPerimetro(): number {
        return 4*this.latoA;
    }
    public getArea(): number {
        return Math.pow(this.latoA,2);
    }
}
 
class Rettangolo implements IFiguraGeometrica{
    public constructor(private latoA:number,private latoB:number){}
    public getTipoFigura():string{
        return "Rettangolo";
    }
    public getPerimetro(): number {
        return (2*this.latoA)+(2*this.latoB);
    }
    public getArea(): number {
        return this.latoA*this.latoB;
    }
}
 
class Triangolo implements IFiguraGeometrica{
    public constructor(private latoA:number,private latoB:number,private latoC:number){}
    public getTipoFigura():string{
        return "Triangolo";
    }
    public getPerimetro(): number {
        return this.latoA+this.latoB+this.latoC;
    }
    public getArea(): number {
        let sp=this.getPerimetro()/2;
        let area=Math.sqrt(sp*(sp-this.latoA)*(sp-this.latoB)*(sp-this.latoC))
        return area;
    }
}
class Geometria {
    private figureGeometriche:IFiguraGeometrica[]=[]
    public add(figuraGeometrica:IFiguraGeometrica):void{
        this.figureGeometriche.push(figuraGeometrica);
    }
    public stampa(){
        this.figureGeometriche.forEach(figuraGeometrica =>{
            console.log("Tipo figura:"+figuraGeometrica.getTipoFigura());
            console.log("Perimetro  :"+figuraGeometrica.getPerimetro());
            console.log("Area       :"+figuraGeometrica.getArea());
        })
    }
}
class Main{
public static main():void{
    var cerchio:IFiguraGeometrica=new Cerchio(10);
    var quadrato:IFiguraGeometrica=new Quadrato(20);
    var rettangolo:IFiguraGeometrica=new Rettangolo(10,20);
    var triangolo:IFiguraGeometrica=new Triangolo(5,10,10);
    var geometria:Geometria=new Geometria();
    geometria.add(cerchio);
    geometria.add(quadrato);
    geometria.add(rettangolo);
    geometria.add(triangolo);
    geometria.stampa();
}    
}    
//Main
Main.main();
-----------------------------------------------------------------------

Tipo figura:Cerchio
Perimetro  :62.83185307179586
Area       :314.1592653589793
Tipo figura:Quadrato
Perimetro  :80
Area       :400
Tipo figura:Rettangolo
Perimetro  :60
Area       :200
Tipo figura:Triangolo
Perimetro  :25
Area       :24.206145913796355
 

 

PROPRIETA' ARCHITETTURALI DEL PARADIGMA OBJECT ORIENTED

Le proprietà Architetturali del paradigma object oriented caratterizzano l'organizzazione strutturale di un'applicazione software
Le proprietà architetturali incidono sulla qualità  delle applicazioni, come ad esempio le prestazioni, la scalabilità, la disponibilità la 
riusabilità e la modificabilità.

COESIONE

Le classi sono Coese se sono disegnate per offrire una soluzione specifica, come ad esempio avviene per i servizi che mettono a disposizione funzioni che  risolvono problemi di un particolare dominio applicativo.

Il pattern MVC (Model View Controller), favorisce il disegno di classi coese,  perché permette di distinguere le classi in base al ruolo che devono avere all'interno dell'applicazione.

Se più classi hanno responsabilità (metodi) e caratteristiche (attributi) comuni, probabilmente bisogna creare una nuova classe che le contiene tutte.

Un bravo programmatore ad oggetti, quando sviluppa un'applicazione, rispetta sempre questa regola:

"Metti il codice dove gli altri si aspettano di trovarlo" .

Le classi di tipo model sono coese, perché tutti i loro metodi interni servono per gestire gli attributi privati, non accessibili ai metodi di altre classi. 

 
class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getLuogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public toString():string{
        let optionsIntl.DateTimeFormatOptions = {
            day: "numeric"month: "numeric"year: "numeric"
        };
 
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB"options)+","+this.luogoDiNascita+","+this.sesso;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string){
            this.id=id;
            this.nome=nome;
            this.cognome=cognome;
            this.dataDiNascita=dataDinascita;
            this.luogoDiNascita=luogoDiNascita;
            this.sesso=sesso;
        }    
}
 

Un altro esempio di classi coese, sono quelle di tipo CRUD, specializzate per gestire la persistenza delle classi di tipo model.

Una classe CRUD può essere considerata un servizio.

 
 
interface IPersonaCRUD{
    inserisci(persona:Persona):boolean;
    modifica(indice:number,persona:Persona):boolean;
    cancella(indice:number):boolean;
    leggi(indice:number):Persona;
    leggi():Persona[];
}
 
export class PersonaCRUD implements IPersonaCRUD{
    private persone:Persona[];
    inserisci(personaPersona): boolean {
       this.persone.push(persona);
       return true;
    }
    modifica(indice:numberpersonaPersona): boolean {
        this.persone[indice]=persona;
        return true;
    }
    cancella(indicenumber): boolean {
        this.persone.splice(indice,1);
        return true;  
    }
    // Overload (polimorfismo dei metodi)
    leggi(indicenumber): Persona;
    leggi(): Persona[];
    leggi(indice?: number): Persona | Persona[] {
        if (arguments.length==1){
            return this.persone[indice];
        } else{
        return this.persone;
        }
    }
 
}
 

Anche la classe di utilità Math è coesa, perché contiene tutte le funzionalità richieste per gestire operazioni di matematica, di seguito elenchiamo quelle più importanti:

// matematica.ts
class OperazioniMatematiche{
    public static main():void{
        var numeri:number[]=[10,30,20,5,40];
        console.log("Pi greco:"+Math.PI);
        console.log("Arrotonda per eccesso:"+Math.ceil(Math.PI));
        console.log("Arrotonda per difetto:"+Math.round(Math.PI));
        console.log("Valore assoluto di -10:"+Math.abs(-10));
        console.log("Potenza di 5^2:"+Math.pow(5,2));
        console.log("Radice quadrata di 25:"+Math.sqrt(25));
        console.log("Valore massimo di :"+numeri+" -> "+Math.max(10,30,20,5,40));
        console.log("Valore minimo di :"+numeri+" -> "+Math.min(10,30,20,5,40));
        console.log("Valore casuale da 1 a 100:"+Math.ceil(Math.random()*100));
    }
}
OperazioniMatematiche.main();
-----------------------------------------------------------------------------------
Pi greco:3.141592653589793
Arrotonda per eccesso:4
Arrotonda per difetto:3
Valore assoluto di -10:10
Potenza di 5^2:25
Radice quadrata di 25:5
Valore massimo di :10,30,20,5,40 -> 40
Valore minimo di :10,30,20,5,40 -> 5
Valore casuale da 1 a 100:63
 

DISACCOPPIAMENTO

Per Accoppiamento s'intendono i legami (relazioni di dipendenza)  esistenti tra classi diverse della stessa applicazione.
Minore è il livello di accoppiamento tra le classi e maggiore è la manutenibilità del software, perché oltre a favorire la leggibilità del codice, eventuali modifiche ad una classe hanno basse ripercussioni sulle altre classi.

Si crea un accoppiamento forte tra due classi tutte le volte che un metodo di una classe Client, istanzia un oggetto per usare i metodi oppure gli attributi pubblici di una classe Server, come mostra il diagramma seguente:

 L'accoppiamento è debole se il metodo della classe Client riceve come argomento il riferimento della classe Server senza istanziare un oggetto di tipo Server

Esempio 3

Una classe Persona ha un attributo di tipo Indirizzo, composto dal nome della strada, il cap, la città e la provincia.
Per creare l'attributo di tipo Indirizzo nella classe Persona utilizziamo la classe seguente:

 
//indirizzo.ts
export class Indirizzo {
    private nomeStrada:string;
    private cap:string;
    private citta:string
    private provincia:string;
    public getNomeStrada():string{
        return this.nomeStrada;
    }
    public setNome(nomeStrada:string):void{
        this.nomeStrada=nomeStrada;
    }
    public getCap():string{
        return this.cap;
    }
    public setCap(cap:string):void{
        this.cap=cap;
    }
    public getCitta():string{
        return this.citta;
    }
    public setCitta(citta:string):void{
        this.citta=citta;
    }    
    public getProvincia():string{
        return this.provincia;
    }
    public setProvincia(provincia:string):void{
        this.provincia=provincia;
    }    
    public toString():string{
        return this.nomeStrada+","+this.cap+","+this.citta+","+this.provincia;
    }
    public constructor();
    public constructor(nomeStrada:string,cap:string,citta:string,provincia:string);
    public constructor(nomeStrada?:string,cap?:string,citta?:string,provincia?:string){
        this.nomeStrada=nomeStrada;
        this.cap=cap;
        this.citta=citta;
        this.provincia=provincia;    
    }
}
 

 

In questo esempio per creare l'attributo di tipo Indirizzo nella classe Persona, stiamo creando un accoppiamento tra la due classi.

A seconda di come viene impostato il metodo setIndirizzo ed il costruttore della classe Persona, l'accoppiamento diventa alto (forte) oppure basso (debole).

A) Accoppiamento alto

 
//persona_con_indirizzo_accoppiamento_alto.ts
import {Indirizzofrom './indirizzo'
export class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    private codiceFiscale:string;
    private indirizzo:Indirizzo=new Indirizzo();
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getluogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public getCodiceFiscale():string{
        return this.codiceFiscale;
    }
    public setCodiceFiscale(codiceFiscale:string):void{
        this.sesso=codiceFiscale;
    }
    public setIndirizzo(nomeStrada:string,cap:string,citta:string,provincia:string){
        this.indirizzo.setNomeStrada(nomeStrada);
        this.indirizzo.setCap(cap);
        this.indirizzo.setCitta(citta);
        this.indirizzo.setProvincia(provincia);
    }
    public getIndirizzo():Indirizzo{
           return this.indirizzo;
    }
    public toString():string{
        let optionsIntl.DateTimeFormatOptions = {
            day: "numeric"month: "numeric"year: "numeric"
        };
 
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB"options)+","+this.luogoDiNascita+","+this.sesso+","+this.codiceFiscale+","+this.indirizzo;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string,codiceFiscale:string,nomeStrada:string,cap:string,citta:string,provincia:string);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,nomeStrada?:string,cap?:string,citta?:string,provincia?:string){
            if(arguments.length>0){
                this.id=id;
                this.nome=nome;
                this.cognome=cognome;
                this.dataDiNascita=dataDinascita;
                this.luogoDiNascita=luogoDiNascita;
                this.sesso=sesso;
                this.codiceFiscale=codiceFiscale;
                this.indirizzo.setNomeStrada(nomeStrada);
                this.indirizzo.setCap(cap);
                this.indirizzo.setCitta(citta);
                this.indirizzo.setProvincia(provincia);
                    }
        }    
}
 

In questo caso l'accoppiamento tra la classe Persona e la classe Indirizzo è alto, perché se si modificano gli attributi della classe Indirizzo, necessariamente bisogna modificare anche gli argomenti del metodo setIndirizzo ed del costruttore della classe Persona. 

private indirizzo:Indirizzo=new Indirizzo(); 
...
    public setIndirizzo(nomeStrada:string,cap:string,citta:string,provincia:string){
        this.indirizzo.setNomeStrada(nomeStrada);
        this.indirizzo.setCap(cap);
        this.indirizzo.setCitta(citta);
        this.indirizzo.setProvincia(provincia);
    }
...
public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,nomeStrada?:string,cap?:string,citta?:string,provincia?:string){
            if(arguments.length>0){
                this.id=id;
                this.nome=nome;
                this.cognome=cognome;
                this.dataDiNascita=dataDinascita;
                this.luogoDiNascita=luogoDiNascita;
                this.sesso=sesso;
                this.codiceFiscale=codiceFiscale;
                this.indirizzo.setNomeStrada(nomeStrada);
                this.indirizzo.setCap(cap);
                this.indirizzo.setCitta(citta);
                this.indirizzo.setProvincia(provincia);
                    }
}    

 

B) Accoppiamento basso

 
//persona_con_indirizzo_accoppiamento_basso.ts
import {Indirizzofrom './indirizzo'
export class Persona{
    private id:number;
    private nome:string;
    private cognome:string;
    private dataDiNascita:Date;
    private luogoDiNascita:string;
    private sesso:string;
    private codiceFiscale:string;
    private indirizzo:Indirizzo;
    public setId(id:number):void{
        this.id=id;
    }
    public getId():number{
        return this.id;
    }
    public setNome(nome:string):void{
        this.nome=nome;
    }
    public getNome():string{
        return this.nome;
    }
    public setCognome(cognome:string):void{
        this.cognome=cognome;
    }
    public getCognome(){
        return this.cognome;
    }
    public setDataDiNascita(dataDiNascita:Date):void{
        this.dataDiNascita=dataDiNascita;
    }
    public getDataDiNascita():Date{
        return this.dataDiNascita;
    }
    public setLuogDiNascita(luogoDiNascita:string):void{
        this.luogoDiNascita=luogoDiNascita;
    }
    public getluogoDiNascita():string{
        return this.luogoDiNascita;
    }
    public setSesso(sesso:string):void{
        this.sesso=sesso;
    }
    public getSesso():string{
        return this.sesso;
    }
    public getCodiceFiscale():string{
        return this.codiceFiscale;
    }
    public setCodiceFiscale(codiceFiscale:string):void{
        this.sesso=codiceFiscale;
    }
    public setIndirizzo(indirizzo:Indirizzo){
        this.indirizzo=indirizzo;
    }
    public getIndirizzo():Indirizzo{
           return this.indirizzo;
    }
    public toString():string{
        let optionsIntl.DateTimeFormatOptions = {
            day: "numeric"month: "numeric"year: "numeric"
        };
 
           return this.id+","+this.nome+","+this.cognome+","+this.dataDiNascita.toLocaleDateString("en-GB"options)+","+this.luogoDiNascita+","+this.sesso+","+this.codiceFiscale+","+this.indirizzo;
    }
    public equals(obj:Object):boolean{
        if (this.toString()!=obj.toString()){
            return false;
        }
        return true;
    }
        // Sovraccarico del costruttore
        public constructor();
        public constructor(id:number,nome:string,cognome:string,dataDinascita:Date,luogoDiNascita:string,sesso:string,codiceFiscale:string,indirizzo:Indirizzo);
        public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,indirizzo?:Indirizzo){
            if(arguments.length>0){
                this.id=id;
                this.nome=nome;
                this.cognome=cognome;
                this.dataDiNascita=dataDinascita;
                this.luogoDiNascita=luogoDiNascita;
                this.sesso=sesso;
                this.codiceFiscale=codiceFiscale;
                this.indirizzo=indirizzo;
            }
        }    
}
 

  

In questo caso l'accoppiamento tra la classe Persona e la classe Indirizzo è basso perché se si modificano gli attributi della classe Indirizzo, non bisogna modificare gli argomenti del metodo setIndirizzo e del costruttore della classe Persona, poiché contengono semplicemente il riferimento della classe indirizzo.

private indirizzo:Indirizzo;
...
    public setIndirizzo(indirizzo;Indirizzo){
        this.indirizzo=indirizzo;
    }
...
public constructor(id?:number,nome?:string,cognome?:string,dataDinascita?:Date,luogoDiNascita?:string,sesso?:string,codiceFiscale?:string,indirizzo?:Indirizzo){
            if(arguments.length>0){
                this.id=id;
                this.nome=nome;
                this.cognome=cognome;
                this.dataDiNascita=dataDinascita;
                this.luogoDiNascita=luogoDiNascita;
                this.sesso=sesso;
                this.codiceFiscale=codiceFiscale;
                this.indirizzo=indirizzo;
                    }
}    

DIPENDECY INJECTION

La Dipendency Injection è una particolare forma del pattern Inversion Of Control (IoC), che rende una classe indipendente dell'inizializzazione delle proprie dipendenze.
Questa caratteristica riduce il livello di accoppiamento tra le classi ed aumenta la manutenibilità dell'applicazione.

In parole semplici, con la Dipendency Injection i metodi oppure i costruttori di una classe non istanziano gli oggetti con il comando new, ma ricevono direttamente i loro riferimento come argomento passato dal contesto applicativo.

Nella programmazione tradizionale è lo sviluppatore che si occupa di tutte le operazioni di creazione, inizializzazione ed invocazione dei metodi degli oggetti, l'IoC invece inverte il control flow facendo in modo che non sia più lo sviluppatore a doversi preoccupare di questi aspetti, ma il framework, che reagendo a qualche “stimolo” se ne occuperà per suo conto.

Se sviluppate con Java il framework più usato è SPRING, se sviluppate con TypeScript il più usato è ANGULAR.

 

Nella prossima lezione vedremo come manipolare gli elementi del DOM delle pagine  HTML.


<< Lezione precedente | Vai alla prima lezione


T U T O R I A L S    S U G G E R I T I


EDUCATIONAL GAMING BOOK (EGB) "H2O"

Nell'era dello SMART LEARNING e di PYTHON i libri non si scrivono, ma si sviluppano, in questo modo chi studia, può sperimentare ed apprendere contemporaneamente; un libro con queste caratteristiche lo possiamo definire un  Educational Gaming Book (EGB).

"H2Oè un EGB che descrive tutte le caratteristiche dell'acqua, la sostanza formata da molecole di H2O, che attraverso il suo ciclo di vita garantisce la sopravvivenza di tutti gli esseri viventi del Pianeta

L'obiettivo dell'EGB è quello di far conoscere ai giovani le proprietà dell'acqua, sotto molti aspetti uniche, per sensibilizzarli a salvaguardare un bene comune raro, indispensabile per la vita


Per il DOWNLOAD di "H2Oclicca qui.

Share Button

Cassa Integrazione: per molti dipendenti, oltre al danno, la beffa ...

Gino Visciano | Skill Factory - 05/08/2020 17:24:52 | in Home

E' ormai noto a tutti che, nonostante le rassicurazioni dell'INPS e le promesse del governo, molti dipendenti in cassa integrazione devono ancora ricevere parte dei soldi dei mesi di marzo ed aprile e  quasi nessuno ha ricevuto i soldi dei mesi di maggio e giugno.

Ma purtroppo i  disagi non sembrano finire qui!

Alcuni dipendenti in cassa integrazione ci hanno segnalato che per qualche ingiustificato e scellerato motivo, l'INPS non sta versando i soldi della cassa integrazione sul conto corrente bancario indicato nella domanda di cassa integrazione, questo nonostante sia stato fornito un IBAN valido, ma sta inviando un mandato di pagamento che li obbliga a ritirare i soldi presso gli sportelli delle Poste Italiane

Questa cosa è molto grave, perché per ritirare i propri soldi, bisogna fare lunghe file, anche di alcune ore, che inevitabilmente provocano  assembramenti ed aumentano  il rischio di contrarre il COVID, proprio quello che si voleva evitare chiudendo le aziende ed introducendo l'uso dello smart-working.

Ma c'è dell'altro ...

Qualcuno ci ha anche raccontato che per motivi di antiriciclaggio, per ritirare i propri soldi è stato costretto, per fortuna gratuitamente, ad aprire un libretto postale, su cui depositare i soldi, per poi poterli ritirare successivamente allo sportello oppure attraverso la carta BMT.

Sicuramente dietro a tutto questo disagio esisterà una spiegazione logica, soprattutto in un periodo di emergenza come quello che stiamo vivendo, ma nell'era digitale, dove tutto può essere fatto a distanza, è difficile credere che sia solo inefficienza, probabilmente ci sono anche altri interessi di tipo commerciale.

Share Button

TypeScript - Lezione 6: Paradigma Object Oriented (prima parte)

Gino Visciano | Skill Factory - 28/07/2020 23:29:50 | in Tutorials

Il paradigma Object Oriented prevede che le applicazioni siano  composte da un insieme di componenti, chiamti oggetti oppure istanze, che collaborano tra loro per svolgere un lavoro o risolvere un problema.

Il Diagramma di collaborazione seguente mostra un esempio di applicazione Object Oriented.

 

Tutte le applicazioni si possono assemblare utilizzando tre tipi di oggetti: 

- I MODEL sono oggetti che contengono i dati di un entità, corrispondono ai record delle tabelle, permettono di memorizzare temporaneamente i dati in memoria;
- Le 
VIEW sono oggetti oppure viste,  come ad esempio le pagine htmlpermettono la visualizzazione oppure l'inserimento di informazioni;
- I 
CONTROLLER  sono oggetti che hanno il compito di gestire un flusso logico applicativo, all'interno della stessa applicazione ci possono essere anche più CONTROLLER.

L'immagine seguente mostra un diagramma di classe che descrive una classe  che contiene gli attributi di una Persona.

Con una classe di questo tipo è possibile istanziare oggetti di tipo MODEL.

L'immagine seguente mostra il mockup di una pagina.html che permette di inserire i dati che verranno memorizzati in un oggetto di tipo Persona:

L'immagine seguente mostra un diagramma di classe con la classe GestionePersone di tipo CONTROLLER che, attraverso il metodo main, implementa la logica necessaria per gestire oggetti di tipo Persona: 

 

COLLABORAZIONE TRA COMPONENTI

Quando si lavora con un linguaggio ad oggetti bisogna ricordare alcune regole importanti per permettere la collaborazione (comunicazione) tra i componenti dell'applicazione:

1) Una classe diventa un componente (oggetto) quando s'istanzia, solo in questo caso è possibile usare gli attributi ed i metodi pubblici, come mostra il codice TypeScript seguente:

Persona personaUno = new Persona();
Persona personaDue = new Persona();
personaUno.setNome("Pippo");
personaUno.setCognome("Rossi");
personaUno.setEta(35);
personaDue.setNome("Carla");
personaDue.setCognome("Verdi");
personaDue.setEta(30);

L'immagine seguete mostra prima il Diagramma di Classe che descrive la classe Persona, di seguito attraverso un Diagramma ad Oggetti vengono descritti gli stati delle istanze (oggetti) dei due compenenti di tipo MODEL  creati usando la classe Persona.

I due componenti istanziati sono stati allocati in memoria e gli indirizzi (riferimenti) memorizzati nelle variabili personaUno e personaDue di tipo Persona.

2) Gli attributi ed i metodi  pubblici di una classe si definiscono Interfaccia. I componenti possono collaborare (comunicare) tra loro solo attraverso l'interfaccia.  

Ad esempio l'interfaccia della classe Persona è composta solo dai metodi:

public setNome(nome:string):void;
public setCognome(cognome:string):void;
public setEta(eta:number):void;
public getNome():string;
public getCognome():string;
public getEta():int;

perché gli attributi sono tutti privati e non possono essere visibili agli altri componenti.

3) Un componente che usa gli attributi ed i metodi pubblici (interfaccia) di un altro componenete ha il ruolo di Client, l'altro ha il ruolo di Server

L'immagine seguente mostra la classe Prima, di tipo Client, perché attraverso i metodi stampaDivisione() e stampaValore(), utilizza l'attributo valore ed il metodo divisione(...) della classe Seconda, che ha il ruolo di Server.

I metodi di una classe Client per usare gli attributi ed i metodi pubblici (interfaccia) di una classe Server devono istanziarla, come mostra l'esempio seguente:

Esempio 1

 
// prima.ts classe Client
import {Secondafrom './seconda'
export class Prima{
    public stampaDivisione():void{
        //Istanza classe Server
        var seconda:Seconda =new Seconda();
        console.log("Divisione 10/5="+seconda.divisione(10,5));
    }
    public stampaValore():void{
        //Istanza classe Server
        var seconda:Seconda =new Seconda();
        console.log("valore="+seconda.valore);
    }
}
 

 

 
// seconda.ts classe Server
export class Seconda{
    //Interfaccia classe Server perché entrambi gli elementi sono pubblici
    public valore:number=10;
    public divisione(dividendo:number,divisore:number):number{
        return dividendo/divisore;
    }
}
 

 

 
import {Primafrom './prima'
//Istanza classe Prima perché per poter usare 
//i suoi elementi pubblici deve diventare un componente 
var prima:Prima=new Prima();
prima.stampaDivisione();
prima.stampaValore();
 

 

Tra la classe Client Prima e la classe Server Seconda esiste una dipendenza, perché entrambi i metodi stampaDivisione() e stampaValore() di classe Prima istanziano un componente di tipo Seconda.

Quando esiste una dipendenza le classi si dicono accoppiate


PROPRIETA' DEL PARADIGMA OBJECT ORIENTED

Il paradigma Object Oriented prevede tre proprietà di programmazione e due architetturali.

Proprietà di programmazione:

1) Incapsulamento
2) Ereditarietà
3) Polimorfismo

Il Polimorfismo può essere diviso in:

1) Polimorfismo dei metodi: Overload ed Override
2) Polimorfismo degli oggetti, che si può ottenere per ereditarietà oppure per interfaccia.

Le proprietà di programmazione permettono di sviluppare le classi ed impostare le loro caratteristiche ed il loro comportamento

Proprietà architetturali:

1) Coesione
2) Disaccoppiamento

Le proprietà architetturali permettono d'impostare la struttura e l'organizzazione delle applicazioni ad oggetti, per migliorarne le funzionalità e la qualità

 

PROPRIETA' DI PROGRAMMAZIONE DEL PARADIGMA OBJECT ORIENTED

Le proprietà descritte di seguito sono disponibili unicamente nei linguaggio orientatti agli oggetti (Object Oriented),  come ad esempio: C++, C#, Java, TypeScript e Python.

INCAPSULAMENTO

L'incapsulamento, attraverso i modificatori di accesso,  permette di regolare la visibilità e quindi l'utilizzo degli elementi di una classe:

- Attributi
- Metodi
- Costruttori

da parte dei metodi di altre classi.

I modificatori di accesso disponbili in TypeScript sono:

- public         (+, notazione UML)
- private        (-, notazione UML)
- protected  (#, notazione UML)

a)  un elemento è public è visibile a tutti i metodi sia della classe a cui appartiene, sia ai metodi di altre classi.
b)  un elemento è private è visibile solo a tutti i metodi della classe a cui appartiene, ma non è visibile ai metodi di altre classi.
c)  un elemento è protected è visibile solo a tutti i metodi della classe a cui appartiene ed a quelli delle classi che ereditano la classe che contiene l'elemento protected, ma non è visibile ai metodi di altre classi.

 


Esempio 2

 
// incapsulamento.rs
class Test{
public a:number=10;
private b:number=20;
protected c:number=30;
}
class TestA{
public eseguiTest(){
     // Verifica incapsulamento per istanza (dipendenza)
     var test:Test=new Test();
     console.log("a="+test.a+" (public)")
     console.log("b=non visibile (private)");
     console.log("c=non visibile (protected)");
}
}
class TestB extends Test{
    public eseguiTest(){
         // Verifica incapsulamento per ereditarietà
         console.log("a="+this.a+" (public)")
         console.log("b=non visibile (private)");
         console.log("c="+this.c+" (protected)");
    }
    }
 
// Controller
class Main{
    public static main(){
        var testA:TestA=new TestA();
        var testB:TestB=new TestB();
        console.log("----- Test incapsulamento per dipendenza -----")
        testA.eseguiTest();
        console.log("----- Test incapsulamento per ereditarietà -----")
        testB.eseguiTest();
    }
}
 
//main
Main.main();
 
----------------------------------------------------------------------------
----- Test incapsulamento per dipendenza -----
a=10 (public)
b=non visibile (private)
c=non visibile (protected)
----- Test incapsulamento per ereditarietà -----
a=10 (public)
b=non visibile (private)
c=30 (protected)
 

 

EREDITARIETA'

L'Ereditarietà è una tecnica di riuso del codice, questa proprietà permette di creare una nuova classe, ereditando tutti gli elementi public e protected di un'altra classe, chiamata classe padre.
La classe figlia o derivata può contenere nuovi elementi che permettono di specializzare la classe Padre ereditata

L'Ereditarietà è quasi sempre singola, ovvero una classe figlia può ereditare una sola classe per volta, l'unico linguaggio che permette l'ereditarietà multipla è il C++.

 

EREDITARIETA': REGOLA DEL COSTRUTTORE PARAMETRIZZATO

In caso di ereditarietà, se nella classe padre è presente un costruttore parametrizzato, i suoi argomenti devono essere alimentati dal costruttore della classe figlia, con il metodo super(...), come mostra l'immagine seguente:
 

 

POLIMORFISMO DEI METODI

- OVERLOAD

L'Overload è la proprietà dell'Object Oriented che permette di usare nella stessa classe metodi con lo stesso nome, ma firma diversa.

La firma di un metodo è composta dal nome del metodo più i tipi degli argomenti passati, come mostra l'immagine seguente:

Nella stessa classe possono essere presenti più costruttori con lo stesso nome grazie all'overload, come mostra l'esempio seguente:

Persona() // Costruttore dei default
Persona(nome:string,cognome:string,eta:int) // Costruttore parametrizzato

Firma 1=Persona
Firma 2=Persona+string+string+int

Esempio 3

L'esempio seguente mostra la classe Colori con tre metodi con lo stesso nome, ma firma diversa:
1) colora+string, questo metodo fornisce in output il nome del colore fornito in input come argomento;
2) colora+number, questo metodo fornisce in output il colore corrispondente al progressivo numerico fornito in input come argomento;
3) colora+number+number+number, questo metodo fornisce in output il codice esadecimale del colore corrispondente al codice R,G,B (RED=decimale,GREEN=decimale,BLUE=decimale) fornito in input come argomento.
 

Attenzione in TypeScript l'overload si gestisce con una funzione con argomenti opzionali e l'uso d'interfacce che permettono di definire le firme consentite, come mostra il codice seguente:

 
class Colori {
    public colora(valoreUno:string):string;
    public colora(valoreUno:number):string;
    public colora(valoreUno:number,valoreDue:number,valoreTre:number):string;
    public colora(valoreUno:string | number,valoreDue?:number,valoreTre?:number):string{
    if(arguments.length==3){
        return  "#"+valoreUno.toString(16)+valoreDue.toString(16)+valoreTre.toString(16);
    } else{
        if (typeof valoreUno=="number") {
            switch(valoreUno){
                case 1:
                    return "rosso";
                    break;
                case 2:
                    return "verde";
                    break;
                case 3:
                    return "bianco";
                    break;
                default:
                    return "nero";
                    break;
            }
 
        } else{
            return valoreUno;
        }   
    }
  }
// Controller
class Main{
    public static main():void{
var colori:Colori=new Colori();
console.log(colori.colora("rosso"));
console.log(colori.colora(2));
console.log(colori.colora(200,100,255));
    }
}
// main
Main.main();
 
 
--------------------------------------------------
rosso
verde
#c864ff
 

 

- OVERRIDE

L'Override è la seconda proprietà del polimorfismo dei metodi, serve per cambiare il comportamento di un metodo ereditato dalla classe Padre, come mostra l'esempio seguente:

Esempio 4

Se la classe ChiSeiSeconda eredita la classe ChiSeiPrima, il comportamento del metodo toString() è lo stesso, sia per un oggetto di tipo ChiSeiPrima, sia per un oggetto di tipo ChiSeiSeconda.

 
class ChiSeiPrima {
    public toString():string{
           return "Sono la classe ChiSeiPrima!" ;
    }
}
class ChiSeiSeconda extends ChiSeiPrima{
}
// Controller
class Main{
    public static main():void{
        var chiSeiPrima=new ChiSeiPrima();
        var chiSeiSeconda=new ChiSeiSeconda();
        console.log(chiSeiPrima.toString());
        console.log(chiSeiSeconda.toString());
    }
}
// main
Main.main();
 
------------------------------------------
Sono la classe ChiSeiPrima!
Sono la classe ChiSeiPrima!
 

 

Esempio 5

Se sovrascrivete (override) il metodo  toString() nella classe ChiSeiSeconda, allora il comportamento del metodo sarà diveso se l'oggetto è di tipo ChiSeiPrima oppure di tipo ChiSeiSeconda.

 
class ChiSeiPrima {
    public toString():string{
           return "Sono la classe ChiSeiPrima!" ;
    }
}
class ChiSeiSeconda extends ChiSeiPrima{
    //Override
    public toString():string{
        return "Sono la classe ChiSeiSeconda!" ;
 }
}
// Controller
class Main{
    public static main():void{
        var chiSeiPrima=new ChiSeiPrima();
        var chiSeiSeconda=new ChiSeiSeconda();
        console.log(chiSeiPrima.toString());
        console.log(chiSeiSeconda.toString());
    }
}
 
----------------------------------------------
Sono la classe ChiSeiPrima!
Sono la classe ChiSeiSeconda!
 
 

 

- OVERRIDE: OPERATORE SUPER

Quando si sovrascrive (override) un metodo in una classe figlia, per poter utilizzare lo stesso metodo della classe Padre, dovete usare l'operatore super

Ricordate che quando istanziate un oggetto utilizzando una classe, l'operatore this diventerà il riferimento dell'oggetto creato, mentre super diventerà il riferimento dell'oggetto padre. 

 
class ChiSeiPrima {
    public toString():string{
           return "Sono la classe ChiSeiPrima!" ;
    }
}
class ChiSeiSeconda extends ChiSeiPrima{
    //Override
    public toString():string{
        return super.toString()+", Sono la classe ChiSeiSeconda!" ;
 }
}
// main
var chiSeiPrima=new ChiSeiPrima();
var chiSeiSeconda=new ChiSeiSeconda();
console.log(chiSeiPrima.toString());
console.log(chiSeiSeconda.toString());
 
-----------------------------------------------
Sono la classe ChiSeiPrima!
Sono la classe ChiSeiPrima!, Sono la classe ChiSeiSeconda!
 

 

Continua nella prossima lezione dove vedremo il Polimorfismo degli oggetti e le proprietà architetturali del paradigma Object Oriented.


<< Lezione precedente           Lezione successiva >> | Vai alla prima lezione


T U T O R I A L S    S U G G E R I T I


EDUCATIONAL GAMING BOOK (EGB) "H2O"

Nell'era dello SMART LEARNING e di PYTHON i libri non si scrivono, ma si sviluppano, in questo modo chi studia, può sperimentare ed apprendere contemporaneamente; un libro con queste caratteristiche lo possiamo definire un  Educational Gaming Book (EGB).

"H2Oè un EGB che descrive tutte le caratteristiche dell'acqua, la sostanza formata da molecole di H2O, che attraverso il suo ciclo di vita garantisce la sopravvivenza di tutti gli esseri viventi del Pianeta

L'obiettivo dell'EGB è quello di far conoscere ai giovani le proprietà dell'acqua, sotto molti aspetti uniche, per sensibilizzarli a salvaguardare un bene comune raro, indispensabile per la vita


Per il DOWNLOAD di "H2Oclicca qui.

Share Button

Non Siamo un'Academy! Siamo una grande community di programmatori Junior ...

Gino Visciano | Skill Factory - 15/07/2020 16:57:14 | in Home

Nell'era dello Storytelling raccontare una storia di successo è gratificante, soprattutto in un momento in cui occorrono certezze,  per superare le difficoltà che stiamo vivendo a causa dell'emergenza COVID.

Quando nel 2011 abbiamo avviato la società "Skill Factory", non pensavamo che a breve saremo diventati una grande "Community di programmatori junior".

Oggi, grazie al nostro lavoro, oltre 2000 giovani hanno avuto la possibilità di accedere a percorsi gratuiti, chiamati skill factory ed entrare nel mondo del lavoro presso uno dei nostri Job partner IT, con un contratto di apprendistato.

Una skill factory è un percorso progettato ad hoc per creare tutte le competenze che servono ad un programmatore e facilitare il percorso richiesto per entrare nel mondo del lavoro. 

Escluso il periodo di tirocinio formativo, un percorso di skill factory ha una durata di 320/480 ore ed  ha una percentuale di successo del 60/70%.  

I destinatari sono giovani disoccupati di età compresa tra i 22 ed i 29 anni, diplomati oppure laureati, in cerca di prima occupazione oppure persone che hanno bisogno di riqualificarsi, perché sono alla ricerca di nuove opportunità di lavoro. 

Non siamo un'ACADEMY! 

Non facciamo solo formazione, ma copriamo tutte le fasi richieste dal processo d'inserimento di una risorsa nel modo del lavoro ...

Attraverso la piattaforma www.skillbook.it,  collaboriamo con tutti gli utenti dell'nostra community a cui offriamo i seguenti servizi:

- Informazione;
- Formazione;
- Aggiornamento;
- Certificazione delle competenze;
- Consulenza e Supporto.

 

  
 


Resto a casa a fare formazione ...
Anche durante il lockdown non ci siamo mai fermati, erogando oltre 3000 ore di formazione e laboratorio in Smart-Learning/Working. Grazie al nostro impegno, durante il periodo di emergenza COVID50 giovani programmatori hanno iniziato un tirocinio formativo presso un nostro Job partner IT, con l'opportunità di essere assunti a settembre 2020.  

 


Tutto quello che ti serve per diventare programmatore te lo insegniamo noi!
Vuoi partecipare ad una "Skill Factory"? Invia il tuo CV a recruiting@skillfactory.it, ti contatteremo per verificare se hai i prerequisiti richiesti.
Non cerchiamo talenti o esperti d'Informatica, ma giovani seri volenterosi, predisposti a risolvere problemi logici.   


Sei un programmatore esperto?
Pensi che la tua esperienza possa essere utile agli utenti della nostra community?
Cosa aspetti, conttattaci!  Puoi diventare un nostro "Competence partner" e dare valore alla tua esperienza ...

mail: sid@skillfactory.it 


Per far parte della nostra community registrati su www.skillbook.it.


T U T O R I A L S    S U G G E R I T I


EDUCATIONAL GAMING BOOK (EGB) "H2O"

Nell'era dello SMART LEARNING e di PYTHON i libri non si scrivono, ma si sviluppano, in questo modo chi studia, può sperimentare ed apprendere contemporaneamente; un libro con queste caratteristiche lo possiamo definire un  Educational Gaming Book (EGB).

"H2Oè un EGB che descrive tutte le caratteristiche dell'acqua, la sostanza formata da molecole di H2O, che attraverso il suo ciclo di vita garantisce la sopravvivenza di tutti gli esseri viventi del Pianeta

L'obiettivo dell'EGB è quello di far conoscere ai giovani le proprietà dell'acqua, sotto molti aspetti uniche, per sensibilizzarli a salvaguardare un bene comune raro, indispensabile per la vita


Per il DOWNLOAD di "H2Oclicca qui.

Share Button
TOP