Le Leggi Fondamentali della stupidità umana

Ho da poco letto un saggio dello storico ed economista italiano Carlo M. Cipolla, dopo che mi è capitata una frase su un libro in cui si parlava di Etica e che mi ha particolarmente colpito:

“E’ intelligente chi fa il bene suo e degli altri, è bandito chi fa il bene suo e il male degli altri, è sprovveduto chi fa il bene degli altri e il male suo, è stupido chi fa il male suo e degli altri”

 

Il saggio in questione si intitola “Le leggi fondamentali della stupidità umana” (1988) e ve lo allego di seguito.

 

Leggi della stupidità umana di Cipolla
Titolo: Leggi della stupidità umana di Cipolla (0 click)
Etichetta:
Filename: leggi_stupidita-2.pdf
Dimensione: 192 kB

 

Vi consiglio di leggerlo perché, anche se apparentemente ironico, è (ahimè) alquanto realistico e rispecchia appieno la realtà sociale di questo periodo.

stupidita-cipolla

Ecco la classificazione che Cipolla dà degli esseri umani:

Gli esseri umani si dividono in SPROVVEDUTI, INTELLIGENTI, BANDITI e STUPIDI.
I Banditi sono quelli che si procurano un guadagno a scapito di altri, i quali subiscono una perdita.
Gli Sprovveduti sono quelli che realizzano un’azione il cui risultato comporta una perdita per lui ed un guadagno per gli altri.
Gli Intelligenti sono quelli che realizzano un’azione dalla quale lui e gli altri traggono un vantaggio.
La nostra vita è però punteggiata da vicende in cui si incorre in perdite di denaro, tempo, energia, appetito, tranquillità e buonumore a causa delle improbabili azioni di qualche assurda creature che capita nei momenti più impensabili e sconvenienti a provocarci danni, frustrazioni e difficoltà, senza aver assolutamente nulla da guadagnare da quello che compie. La persona in questione è stupida.

 

Ecco le 5 Leggi Fondamentali della stupidità umana proposte da Cipolla:

1° Legge. Sempre ed inevitabilmente ognuno di noi sottovaluta il numero di individui stupidi in circolazione
2° Legge. La probabilità che una certa persona sia stupida è indipendente da qualsiasi altra caratteristica della stessa persona
3° Legge. Una persona stupida è una persona che causa un danno ad un’altra persona o un gruppo di persone senza nel contempo realizzare alcun vantaggio per sé od addirittura subendo una perdita.
4° Legge. Le persone non stupide sottovalutano sempre il potenziale nocivo delle persone stupide. In particolare i non stupidi dimenticano costantemente che in qualsiasi momento e luogo, ed in qualunque circostanza, trattare e/o associarsi con individui stupidi si dimostra infallibilmente un costosissimo errore.
5° Legge. La persona stupida è il tipo di persona più pericoloso che esista
Corollario 5° Legge. Lo stupido è più pericoloso del bandito

 

Mi sono appuntato delle frasi del saggio che qui condivido:

  • La maggior parte delle persone non agisce coerentemente. In certe circostanze una persona agisce intelligentemente e in altre quella stessa persona si comporta da sprovveduto. Una persona intelligente può talvolta comportarsi da sprovveduto, come può talvolta assumere un comportamenti banditesco. L’unica eccezione alla regola è rappresentata dalle persone stupide che normalmente mostrano una massima propensione per una piena coerenza in ogni campo di attività.
  • Alcuni individui ereditano notevoli dosi del gene della stupidità e grazie a tale eredità appartengono, sin dalla nascita, all’élite del loro gruppo. Il secondo fattore che determina il potenziale di una persona stupida deriva dalla posizione di potere e di autorità che occupa nella società. Tra burocrati, generali, politici e capi di stato si ritrova l’aurea percentuale di individui fondamentalmente stupidi la cui capacità di danneggiare il prossimo fu (o è) pericolosamente accresciuta dalla posizione di potere che occuparono (od occupano). Al proposito anche i prelati non vanno trascurati.
  • La domanda che spesso si pongono le persone ragionevoli è in che modo e come mai persone stupide riescano a raggiungere posizioni di potere e di autorità. Classe e casta (sia laica che ecclesiastica) furono gli istituti sociali che permisero un flusso costante di persone stupide in posizioni di potere nella maggior parte delle società preindustriali. Nel mondo industriale moderno, classe e casta vanno perdendo sempre più di rilievo. Ma, al posto di classe e casta, ci sono partiti politici, burocrazia e democrazia. All’interno di un sistema democratico, le elezioni generali sono uno strumento di grande efficacia per assicurare il mantenimento stabile della frazione a fra i potenti.
  • Va ricordato che, in base alla Seconda Legge, la frazione a di persone che votano sono stupide e le elezioni offrono loro una magnifica occasione per danneggiare tutti gli altri, senza ottenere alcun guadagno dalla loro azione. Esse realizzano questo obiettivo, contribuendo al mantenimento del livello a di stupidi tra le persone al potere.

Infine, il saggio si chiude dicendo che sono meglio i banditi, che traendo guadagno a scapito di altri non comportano un impoverimento/danneggiamento della società, rispetto agli stupidi che, danneggiando sè e gli altri, impoveriscono o danneggiano la società stessa in cui vivono.

[iOs] Accesso alla fotocamera, alla Libreria e modifica di una foto con Aviary

Condivido qui un progettino xCode che esemplifica come accedere ad una foto salvata  nella Libreria Foto oppure scattata direttamente con la fotocamera del vostro device. Una volta prelevata la foto, è possibile modificarla, applicando su di essa vari effetti e filtri, grazie alla libreria Aviary (disponibile non solo per iOs, ma anche per Windows Phone, Android e HTML5).

Aviary-iOS-SDK_4

Ecco il link al mio progetto su GitHubhttps://github.com/fficetola/AviaryExample/

Quindi, ricapitolando, ecco le funzionalità che troverete nell’esempio:

  • visualizzazione di una foto, prelevata dalla Libreria Foto oppure dalla fotocamera del device, in una UIImageView
  • possibilità di modificarla grazie all’editor di Aviary
  • visualizzazione della foto in modalità fullscreen con gesture per lo zoom (pinch-on/pinch-off/double tap)
  • salvataggio dell’immagine modificata nella Libreria Foto

Procediamo per step, descrivendo le funzionalità su elencate (vi invito a visionare i file ViewController.m e BannerViewController.m  in cui vi è tutta la logica di questo tutorial).

 

1. Selezione di una immagine dalla Libreria Foto o dalla fotocamera

La selezione di una foto già salvata in Libreria o scattata dalla fotocamera avviene grazie al controller UIImagePickerController, il quale appare come una modale che a seconda del “source type” richiesto (camera o gallery), vi permetterà di importare appunto la foto da libreria o fotocamera.

- (void) selectPhoto:(UIImagePickerControllerSourceType) pickerType {

    picker = [[UIImagePickerController alloc] init];
    picker.delegate = self;

    picker.sourceType = pickerType;
    //picker.sourceType = UIImagePickerControllerSourceTypeCamera;
    //picker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;

    [self presentModalViewController:picker animated:YES];

}

Il parametro in input al metodo selectPhoto è di tipo UIImagePickerControllerSourceType e può essere valorizzato con i seguenti valori:

  • UIImagePickerControllerSourceTypeCamera
  • UIImagePickerControllerSourceTypePhotoLibrary

I metodi di callback, che permettono di intercettare se l’utente ha selezionato o meno una foto, sono quelli dell’UIImagePickerControllerDelegate (metodi implementati nel ViewController):

#pragma mark - UIImagePicker Delegate

-(void)imagePickerControllerDidCancel:(UIImagePickerController *) photopicker {

    [photopicker dismissModalViewControllerAnimated:YES];

    [photopicker release];

}

- (void)imagePickerController:(UIImagePickerController *) photopicker didFinishPickingMediaWithInfo:(NSDictionary *)info {

    imageView.image = [info objectForKey:UIImagePickerControllerOriginalImage];
    [photopicker dismissModalViewControllerAnimated:YES];
    [photopicker release];

}

A cosa servono questi metodi del delegate?

  • imagePickerControllerDidCancel: permette di intercettare il click sul tasto Annulla del picker (o della libreria o della fotocamera), quindi senza che sia avvenuta la selezione della foto. In questo metodo viene chiuso il picker (con il dismissModalViewControllerAnimated)
  • didFinishPickingMediaWithInfo: permette di intercettare il click sul tasto Done con conseguente scelta della foto. Il recupero dell’immagine selezionata viene fatto accedendo alla proprietà UIImagePickerControllerOriginalImage del dizionario. Nell’esempio, tale foto viene inserita in una UIImageView per la visualizzazione.

 

2. Modifica dell’immagine con Aviary 

ios_aviary

Per poter modificare la foto, applicandovi  filtri ed effetti vari (cropping, resizing, rotating, ecc.), ho utilizzato la libreria Aviaryla cui versione “free” vi permette di eseguire tutte le features disponibili, ma non di trattare foto ad altissima risoluzione (vedi i dettagli nella sezione Pricing del sito www.aviary.com). Per maggiori dettagli sulle funzionalità previste, ecco la pagina della documentazione per iOshttp://www.aviary.com/ios/documentation

L’installazione della libreria Aviary nel vostro progetto è molto semplice:

  1. Innanzitutto scaricate il progetto di esempio direttamente dal sito ufficiale di Aviary: lo troverete nella sezione Documentazione, cliccando sul bottone GET CODE. Potete eseguirlo per vedere quali sono le features messe a disposizione dalla libreria o come esempio per implementare funzionalità più avanzate (visto che in questo tutorial vi spiego solo l’uso di base)
  2. Registratevi al sito (gratuitamente) per ottenere un’API key, che dovrete inserire all’interno del vostro progetto. Basta cliccare sul bottone GET API KEY della sezione Documentazione, registrarvi e poi aggiungere una nuova app. Vi verranno generate una API Key e una Secret Key ( a voi servirà solo la prima).
  3. Dal codice di esempio scaricato dal sito ufficiale, dovrete copiare la cartella AviarySDK e importarla nel vostro progetto. Questa contiene la libreria libAviarySDK.a, i file di Header e di Resources. Copiatela integralmente nel vostro progetto.
  4. inserite nel vostro progetto i seguenti framework, da cui Aviary dipende:
    1. Accelerate.framework
    2. AdSupport.framework (selezionare `Optional` invece di `Required`)
    3. CoreData.framework
    4. CoreText.framework
    5. libsqlite3.0.dylib
    6. libz.1.2.5.dylib
    7. Foundation.framework
    8. MessageUI.framework
    9. OpenGLES.framework
    10. QuartzCore.framework
    11. StoreKit.framework
    12. SystemConfiguration.framework
    13. UIKit.framework
  5. Infine, inserite nel vostro file MyProject-Info.plist la chiave Aviary-API-Key valorizzandola con l’API Key generata al punto 2.

Dopo la fase di configurazione della libreria, si passa all’utilizzo vero e proprio dell’editor. Innanzitutto il ViewController deve avere come delegate la classe AFPhotoEditorControllerDelegate, che ci permetterà di interagire con l’editor di Aviary, ossia con la classe AFPhotoEditorController.

Ecco come far apparire l’editor di Aviary in una modale del ViewController:

- (void)displayEditorForImage:(UIImage *)imageToEdit
{
    AFPhotoEditorController *editorController = [[AFPhotoEditorController alloc] initWithImage:imageToEdit];
    [editorController setDelegate:self];
    [self presentViewController:editorController animated:YES completion:nil];
}

Basta passare all’AFPhotoEditorController l’immagine da modificare (imageToEdit), in modo da farla apparire nell’editor. Qui Aviary vi permetterà di applicare gli effetti e i filtri disponibili. Per poter intercettare le modifiche o l’annullamento delle modifiche (chiusura con tasto Annulla dell’editor), basta implementare i seguenti metodi dell’ AFPhotoEditorControllerDelegate:

#pragma mark - Aviary Delegate

- (void)photoEditor:(AFPhotoEditorController *)editor finishedWithImage:(UIImage *)image
{

    //read modified image
    [imageView setImage:image];

    [self dismissViewControllerAnimated:YES completion:NULL];

}

- (void)photoEditorCanceled:(AFPhotoEditorController *)editor
{
    [self dismissViewControllerAnimated:YES completion:NULL];
}

Penso che le righe di codice precedenti siano abbastanza esplicative: photoEditorCanceled intercetta la chiusura di Aviary (tap su tasto Annulla) e permette di chiudere l’editor (dismissViewControllerAnimated), invece finishedWithImage permette di recuperare l’immagine modificata per riproporla nella UIImageView.

 

3. Zoom in/out dell’immagine (pinch-off/pinch-on o doppio tap per ingrandire/ridurre)

Per poter ingrandire/ridurre la foto visualizzata nell‘UIImageView, nel mio progettino di esempio trovate la classe BannerViewController.m. In essa vi è la logica per poter eseguire lo zoom-in e lo zoom-out della foto eseguendo le gesture pinch-on/pinch-off o il double tap sulla view. Inoltre, nel file BannerViewController.xib noterete una ScrollView contenente l’UIImageView, in cui visualizzare e zoomare l’immagine.

Ecco il codice:

-(void)handleDoubleTap:(UIGestureRecognizer *)gestureRecognizer {

    if(self.scrollView.zoomScale > scrollView.minimumZoomScale)
        [self.scrollView setZoomScale:scrollView.minimumZoomScale animated:YES];
    else
        [self.scrollView setZoomScale:scrollView.maximumZoomScale animated:YES];
}

- (void)viewDidLoad
{
    [super viewDidLoad];

    self.title = NSLocalizedString(@"BANNER_TITLE", nil);

    self.navigationItem.rightBarButtonItem = [[[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemDone target:self action:@selector(closeModal:)]autorelease];

    UITapGestureRecognizer *tapTwice = [[[UITapGestureRecognizer alloc] initWithTarget:self  action:@selector(handleDoubleTap:)]autorelease];

    tapTwice.numberOfTapsRequired = 2;

    [self.view addGestureRecognizer:tapTwice];

    UIImage *imageFullScreen = image;
    imageView.contentMode = UIViewContentModeScaleAspectFit;
    [self.imageView setImage:imageFullScreen];

    //self.scrollView.contentSize = image.size;
    self.scrollView.delegate = self;
    //self.scrollView.minimumZoomScale = 10.0;
    self.scrollView.maximumZoomScale = 50.0;   

}

Nelle precedenti righe notiamo l’allocazione di un oggetto di tipo UITapGestureRecognizer per la registrazione del doppio “tap” sulla vista: la action associata a tale gesture è handleDoubleTap, che permette di zoomare alla scala massima o minima impostata per la ScrollView. Infatti, il minimumZoomScale e il maximumZoomScale si impostano nel viewDidLoad.

Invece, per gestire le gesture di pinch-on e pinch-off sull’immagine, sono utili le seguenti righe di codice:

- (void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:animated];
    CGPoint centerPoint = CGPointMake(CGRectGetMidX(self.scrollView.bounds),
                                      CGRectGetMidY(self.scrollView.bounds));
    [self view:self.imageView setCenter:centerPoint];
}

- (void)view:(UIView*)view setCenter:(CGPoint)centerPoint
{
    CGRect vf = view.frame;
    CGPoint co = self.scrollView.contentOffset;

    CGFloat x = centerPoint.x - vf.size.width / 2.0;
    CGFloat y = centerPoint.y - vf.size.height / 2.0;

    if(x < 0)
    {
        co.x = -x;
        vf.origin.x = 0.0;
    }
    else 
    {
        vf.origin.x = x;
    }
    if(y < 0)
    {
        co.y = -y;
        vf.origin.y = 0.0;
    }
    else 
    {
        vf.origin.y = y;
    }

    view.frame = vf;
    self.scrollView.contentOffset = co;
}

// MARK: - UIScrollViewDelegate
- (UIView*)viewForZoomingInScrollView:(UIScrollView *)scrollView
{
    return  self.imageView;
}

- (void)scrollViewDidZoom:(UIScrollView *)sv
{
    UIView* zoomView = [sv.delegate viewForZoomingInScrollView:sv];
    CGRect zvf = zoomView.frame;
    if(zvf.size.width < sv.bounds.size.width)
    {
        zvf.origin.x = (sv.bounds.size.width - zvf.size.width) / 2.0;
    }
    else 
    {
        zvf.origin.x = 0.0;
    }
    if(zvf.size.height < sv.bounds.size.height)
    {
        zvf.origin.y = (sv.bounds.size.height - zvf.size.height) / 2.0;
    }
    else 
    {
        zvf.origin.y = 0.0;
    }
    zoomView.frame = zvf;
}

 

4. Salvataggio dell’immagine nella Libreria Foto

Infine, per salvare la foto nella Libreria Foto del device, basta utilizzare la classe nativa UIImageWriteToSavedPhotosAlbum:

//Per salvare la foto modificata nella Gallery

-(void)image:(UIImage *)image finishedSavingWithError:(NSError *)error contextInfo:(void *)contextInfo {

    if (error) {

        UIAlertView *message = [[UIAlertView alloc] initWithTitle:@"Salvataggio Fallito"
                                                          message:@" *ATTENZIONE* non è stato possibile salvare l'immagine"
                                                         delegate:nil
                                                cancelButtonTitle:@"OK"
                                                otherButtonTitles:nil];
        [message show];
    }
    else{
        UIAlertView *message = [[UIAlertView alloc] initWithTitle:@"Salvataggio effettuato con successo"
                                                          message:@"La tua foto è stata salvata nella Gallery"
                                                         delegate:nil
                                                cancelButtonTitle:@"OK"
                                                otherButtonTitles:nil];
        [message show];
    }
}

-(IBAction)savePhotoInGallery:(id)sender{

    //salvo la foto nella Gallery
    UIImageWriteToSavedPhotosAlbum(imageView.image, self, @selector(image:finishedSavingWithError:contextInfo:), nil);
}

[iOs] Come configurare, inviare e ricevere le notifiche push in una app iOs

Eccovi un tutorial su come configurare, inviare e ricevere le push notification di Apple in una app iOs. Tali notifiche sono molto utili nel caso in cui vogliate segnalare aggiornamento ed eventi agli utenti che hanno installato la vostra app e che hanno, ovviamente, dato il consenso per la loro ricezione. La configurazione non è molto immediata, specie la parte di creazione dei certificati, per cui vi descriverò i singoli passi nel dettaglio.

Prima di essere operativi, vediamo il modello di programmazione per capire quali sono le componenti in gioco e il flusso funzionale di registrazione, di accreditamento e di invio/ricezione delle notifiche push:

  1. Push-NotificationL’app, registrata sul Provisioning Portal con un AppID, deve essere configurata in modo da avere la funzionalità di push notification abilitata. Una volta abilitata, occorre generare un Provisioning Profile (sia per l’ambiente di sandbox – o development –   che per quello di production – o distribution) da associare all’app stessa. Lato app, quando l’utente dà il consenso alla ricezione delle notifiche push, si fa richiesta ad iOs per la registrazione e l’autorizzazione alle notifiche.
  2. iOs contatterà il server APNS (Apple Push Notification Service), il quale ricevuta la richiesta, genererà un device token da inoltrare direttamente all’app che ha chiesto la registrazione. Il device token è un “indirizzo” univoco che serve all’APNS per rintracciare il device e per inoltrare le notifiche push tramite l’app.
  3. Una volta ricevuto il device token, dall’app occorrerà richiamare un nostro servizio remoto (registerDevice) in cui registrare tale token, oltre ad una serie di altre info utili del device. L’idea è quella di registrare su un nostro database online, la lista di tutti i device, e relativi device token generati, in modo da inoltrare tutte le nostre notifiche a chi ne ha fatto espressamente richiesta.
  4. Un altro servizio remoto presente sul nostro server (sendPush) sarà responsabile dell’invio delle notifiche push (un semplice messaggio di testo). Tale servizio dovrà essere configurato in modo da avere l’autorizzazione dall’APNS server: occorrerà, dunque, generare e configurare un certificato SSL (e una relativa chiave privata) per poter inoltrare una richiesta di notifica push a ciascun device accreditato.
  5. Quando l’APNS server riceve una richiesta di invio di una notifica push per un determinato device token (dopo aver attestato la veridicità del certificato SSL del servizio remoto sendPush), inoltra la notifica. Dall’altra parte, sul device a cui è associato il device token, verrà visualizzato un alert dell’app (o una notifica nel Centro Notifiche) con il messaggio inviato. Oltre l’alert, si può decidere se riprodorre anche un suono e/o visualizzare un badge (il numeretto con il totale delle notifiche sull’icona dell’app). Cliccando sulla notifica o facendo lo “swipe” sull’alert, verrà aperta la vostra app.

 

NOTA. Non è possibile testare le push notification sul simulatore, ma soltanto direttamente su un iPhone/iPad.

 

Push Notification Payload.  Una richiesta di invio di una push notification (dal nostro server all’APNS server) è fatta da un breve messaggio costituito da un device token a cui indirizzare la notifica, un payload ed altre parti. Il payload contiene il messaggio vero e proprio (in formato JSON), compresi alcuni parametri. In totale non deve superare i 256 bytes. Per maggiori informazioni sui parametri, vedi Local and Push Notification Programming Guide.

Un esempio di messaggio è il seguente:

{"aps":{"alert":"Hello, world!","sound":"default"}}

Vi riporto i tutorial da cui sono partito per poter scrivere questa mini-guida:

 

Partiamo ora con la parte operativa:

 

[GIT] Configurazione di una repository Git

Continuiamo la trattazione sul versioning in Git, richiamando un altro post scritto sull’argomento su questo sito:

Qui viene spiegata la procedura di configurazione locale e remota di una repository Git. Servizi online di hosting molto famosi per il versionamento del vostro codice, gratuiti e a pagamento, sono GitHub, Assembla e BitBucket. Io personalmente utilizzo i primi due: su GitHub versiono i progetti “free” (visto che per renderli privati si paga), su Assembla quelli che voglio rendere privati.

git

Vi linko a tutorial per il versioning su Git, per maggiori approfondimenti:

Vediamo ora gli step per il versionamento su Git. Io uso il Terminale su MacOx, ma la procedura funziona allo stesso modo su Windows, anche se per la generazione delle chiavi SSH dovrete aiutarvi con altri programmi, come Putty.

1. Generazione delle chiavi SSH. Le chiavi SSH servono per stabilire una connessione sicura tra il vostro pc e l’account remoto della repository Git, permettendovi anche l’autenticazione. Dopo aver generato le chiavi sul vostro account remoto (GitHub, per esempio), dovrete copiare nelle Impostazioni la chiave pubblica generata.

cd ~/.ssh
# Ci si sposta nella directory ".ssh" presente sul pc. Se non c'è occorre crearla.

Si generano le chiavi, lanciando il comando ssh-keygen da terminale:

ssh-keygen -t rsa -C "your_email@example.com"
# Crea una nuova chiave SSH con il tuo indirizzo email

# Genera la coppia di chiavi rsa ssh pubblica e privata. A video uscirà un messaggio del genere:
# Enter file in which to save the key (/Users/you/.ssh/id_rsa): [Press enter]
# se non digiti nulla e premi invio, verrà salvata la chiave privata nel file id_rsa della cartella .ssh

Il terminale chiederà anche la passphrase, ossia la password:

Enter passphrase (empty for no passphrase): [Type a passphrase]
# Enter same passphrase again: [Type passphrase again]

Il comando genererà la coppia di chiavi pubblica e privata.

Your identification has been saved in /Users/you/.ssh/id_rsa.
# Your public key has been saved in /Users/you/.ssh/id_rsa.pub.
# The key fingerprint is:
# 01:0f:f4:3b:ca:85:d6:17:a1:7d:f0:68:9d:f0:a2:db your_email@example.com

A questo punto, digitate il seguente comando per copiare la chiave pubblica, da incollare poi nelle Impostazioni dell’account della vostra repo Git (per esempio, su GitHub, vi è la sezione “Add SSH keys” delle Impostazioni Account):

pbcopy < ~/.ssh/id_rsa.pub
# Copia il contenuto del file id_rsa.pub negli Appunti

Eccovi un riferimento utile per questo step: Generating SSH Keys

2. Installazione di Git. Se non già presente, dovete installare Git sul vostro pc (per capire se è già preinstallato, basta lanciare il comando git sul terminale e vedere se vi elenca i vari comandi previsti dal protocollo). L’installazione è molto semplice: basta scaricare l’ultima release da questo link (Git). Altro riferimento utile per questo step: Set Up Git

3. Creazione di una repository. La prima cosa da fare è creare una repository sull’account remoto (di GitHub o Assembla, per esempio). Lì salverete il contenuto del vostro progetto, sincronizzandolo di volta in volta dai vostri pc. Riferimento: Create a repo.

Adesso passiamo alla configurazione della repo GIT locale alle vostre macchine. Spostatevi con il terminale in corrispondenza della directory root del vostro progetto oppure create una directory di progetto da zero. Per esempio:

mkdir ~/Hello-World
# creo una directory di progetto "Hello-World" nella cartella Users

cd ~/Hello-World
# mi sposto in corrispondenza della cartella di progetto appena creata

git init
# inizializzo la cartella di progetto come repository GIT. 
# Ecco il messaggio che vi verrà visualizzato:

# Initialized empty Git repository in /Users/you/Hello-World/.git/

# creo un file README, in cui inserire le informazioni sul progetto
touch README

# committo il file README creato
git add README
# il comando ADD mette il file README nell'area "stage", ossia non è ancora commitato

git commit -m 'first commit'
# committo le modifiche della repository, lasciando il messaggio "first commit"

Se avete inserito (o erano già presenti) altri file/directory nella directory di root (oltre README), allora dovete aggiungerli tutti nell’area “stage”, prima di committarli, con il comando ADD:

# aggiungo tutti i file all'area "stage"
# dopo l'add metto il punto (.)
git add .

git commit -m 'new commit'

Infine, per salvare il tutto sulla repo remota, ecco i comandi:

git remote add origin https://github.com/username/Hello-World.git
# creo una "origin" remota sulla repository GitHub

git push origin master
# mando i commit al branch "master" su GitHub