Capitolo 5 Ambiente di Lavoro

In queso capitolo introdurremo alcuni concetti molto importanti che riguardano l’ambiente di lavoro in R o RStudio. In particolare parleremo dell’environment, della working directory e dell’utilizzo dei pacchetti.

5.1 Environment

Nel Capitolo 4.1, abbiamo visto come sia possibile assegnare dei valori a degli oggetti. Questi oggetti vengono creati nel nostro ambiente di lavoro (o meglio Environment) e potranno essere utilizzati in seguito.

Il nostro Enviroment raccoglie quindi tutti gli oggetti che vengono creati durante la nostra sessione di lavoro. E’ possibile valutare gli oggetti attualmente presenti osservando il pannello Environment in alto a destra (vedi Figura 5.1) oppure utilizzadno il comando ls(), ovvero list objects.

Figure 5.1: Environment - Elenco degli oggetti e variabili presenti nel’ambiente di lavoro

All’inizio della sessione di lavoro il nostro Environment sarà vuoto (vedi Figura 5.2). Il comando ls() non restituirà alcun oggeto ma per indicare l’assenza di oggerri userà la risposta character(0), ovvero un vettore di tipo caratteri di lunghezza zero (vedi Capitolo 7).

Figure 5.2: Environment vuoto ad inizio sessione di lavoro

# Environment vuoto
ls()
## character(0)

5.1.1 Aggiungere Oggetti all’Environment

Una volta creati degli oggetti, questi saranno presenti nel nostro Environment e il comando ls() restituirà un vettore di caretteri in cui vengono elencati tutti i loro nomi.

# Creo oggetti
x <-  c(2,4,6,8)
y <-  27
word <- "Hello Word!"

# Lista nomi oggetti nell'Environment
ls()
## [1] "word" "x"    "y"

Nel pannello in alto a destra (vedi Figura 5.3), possiamo trovare un elenco degli oggetti attualmente presenti nel nostro Environment. Insieme al nome vengono riportate anche alcune utili inforamzioni a seconda del tipo di oggetto. Vediamo come nel nostro esempio, nel caso di variabili con un singolo valore (e.g., word e y) venganno presentati direttamente gli stessi valori. Mentre, nel caso di vettori (e.g., x) vengano fornite anche informazioni riguardanti la tipologia di vettore e la sua dimensione (vedi Capitolo 7), nell’esempio abbiimao un vettore numerico (num) di 4 elementi ([1:4]).

Figure 5.3: Environment contenente gli oggetti creati

5.1.2 Rimuovere Oggetti dall’Environment

Per rimuovere un oggetto dal proprio environment è possibile utilizzare il comando remove() oppure la sua abbreviazione rm(), indicando tra parentesi il nome dell’oggetto che si intende rimuovere. E’ possibile indicare più di un oggetto separando i loro nomi con la virgola.

# Rimuovo un oggetto
rm(word)
ls()
## [1] "x" "y"

# Rimuovo più oggetti contemporaneamente
rm(x,y)
ls()
## character(0)

Qualora fosse necessario eliminare tutti gli oggetti attualmete presenti nel nosto ambiente di lavoro è possibile ricorrere alla formula rm(list=ls()). In questo modo si avrà la certezza di pulire l’ambiente da ogni oggetto e di ripristinarlo alle condizioni iniziali della sessione.

Avere cura di mantenre il proprio Environment ordinato ed essere consapevoli degli oggetti attualmente presenti è importante. Questo ci permette di evitare di compiere due errori comuni.

Utilizzare oggetti non ancora creati. In questo caso l’errore è facilemente individuabile dat che sarà lo stesso R ad avvisarci che “object ‘’ not found”. In questo caso dovremmo semplicemente eseguire il comando per creare l’oggetto richieto.

oggetto_non_esistente
## Error in eval(expr, envir, enclos): object 'oggetto_non_esistente' not found

Utilizzare oggetti con “vecchi” valori. Se non si ha cura di mantenere ordinato il proprio ambiente di lavoro potrebbe accadere che diversi oggetti vengano creati durante successive sessioni di lavoro. A questo punto si corre il rischio di perdere il controllo rispetto al vero contenuto degli oggetti e potremmo quindi utilizzare degli oggetti pensando che contengano un certo valore, quando invece si riferisono a tutt’altro. Questo comporta che qualsiasi nostro risultato perda di significato. Bisogna prestare molta attenzione perchè R non potrà avvisarci di questo errore (per lui sono solo numeri), siamo noi che dobbiamo essere consapevoli del fatto che i comandi eseguiti abbiano senso oppure no.

Per mantere un Environmet ordinato vi consigliamo innanzitutto di non salvare automaticamente il vostro workspace quando terminate una sessione di lavoro. E’ possibile settare tale opzione nelle impostazioni generali di R selezionando “Never” alla voce “save workspace to .RData on exit” come riportato nella Figura seguente.

Questo vi permetterà di iniziare ogni nuova sessione di lavoro in un Environment vuoto, evitando che vecchi oggetti si accumulino nel corso delle diverse sesssioni di lavoro. Durante le vostre sessioni, inoltre, sarà utile eseguire il comando rm(list=ls()) quando inizierete un nuovo compito in modo da eliminare tutti i vecchi oggetti.

Environment una Memoria a Breve Termine

Notiamo quindi come l’Environment sia qualcosa di transitorio. Gli oggetti vengono salvati nella memoria primaria del computer (RAM, possiamo pensarla in modo analogo alla memoria a breve termine dei modelli cognitivi) e verranno cancellati al comando rm(list=ls()) o al termine di ogni sessione di lavoro.

Il fatto di partire ogni volta da un Environment vuoto, vi costringerà a raccogliere tutti i passi delle vostre analisi all’interno di uno script in modo ordinato evitando di fare affidamento su vecchi oggetti. Tutti gli oggetti necessari durante le analisi, infattii, dovranno essere ricreati ad ogni sessione, garantendo la riproducibilità e correttezza del lavro (almeno dal punto di vista di programmazione). Idealmente dovrebbe essere posibile, in una sessione di lavoro, partire da un Environment vuoto ed eseguire in ordine tutti i comandi contenuti in uno script fino ad ottenere i risultati desiderati.

E’ facile intuire come in certe situazioni questa non sia la soluzione più efficiente. Alcuni comandi, infatti, potrebbero richiedere molti minuti (o anche giorni) per essere eseguiti. In questi casi sarebbe conveniente, pertanto, salvare i risultati ottenuti per poterli utilizzare anche in sessioni successive, senza la necessità di dover eseguire nuovamente tutti i comadi. Vedremo nel Capitolo TODO come sarà possibile salvare permanentemente gli oggetti creati nella memoria secondaria del computer (hard-disk, nella nostra analogia la memoria a lungo termine) e come caricarli in una successiva sessione di lavoro.

5.2 Working Directory

Il concetto di working directory è molto importante ma spesso poco conosciuto. La working directory è la posizione all’interno del computer in cui ci troviamo durante la nostra sessione di lavoro e da cui eseguiamo i nostri comandi.

5.2.1 Organizzazione Computer

L’idea intuitiva che abbiamo comunemente del funzionamento del computer è fuorviante. Spesso si pensa che il Desktop rispecchi l’organizzazione del nostro intero computer e che tutte le azioni siano gestite attraverso l’interfaccia punta-e-clicca a cui ormai siamo abituati dai moderni sistemi operativi.

Senza entrare nel dettaglio, è più corretto pensare all’organizzazione del cumputer come ad un insieme di cartelle e sottocartelle che contengono tutti i nostri file e al funzionamento del computer come ad un insieme di processi (o comandi) che vengono eseguiti. Gli stessi programmi che installiamo non sono altro che delle cartelle in cui sono contenuti tutti gli script che determinano il loro funzionamento. Anche il Desktop non è altro che una semplice cartella mentre quello che vediamo noi è un programma definito dal sistema operativo che visualizza il contenuto di quella cartella sul nostro schermo e ci permette di interfacciarci con il mouse.

Tutto quello che è presente nel nostro computer, compresi i nostri file, i programmi e lo stesso sistema operativo in uso, tutto è organizzato in un articolato sistema di cartelle e sottocartelle. Approsimativamente possiamo pensare all’organizzazione del nostro computer in modo simile alla Figura 5.4 (da: https://en.wikipedia.org/wiki/Operating_system).

Figure 5.4: Organizzazione Computer (da Wikipedia vedi link nel testo)

Ai livelli più bassi troviamo tutti i file di sistema ai quali gli utenti possono accedere solo con speciali autorizzazioni. Al livello superiore troviamo tutte i file riguardanti i programmi e applicazioni installati che in genere sono utilizzabili da più utenti sullo stesso computer. Infine troviamo tutte le cartelle e file che riguardano lo specifico utente.

5.2.2 Absolute Path e Relative Path

Questo ampio preambolo riguardante l’organizzazione in cartelle e sottocartelle, ci serve perchè è la struttura che il computer utilizza per orientarsi tra tutti file quando esegue dei comandi attraverso un’interfaccia a riga di comando (e.g., R). Se vogliamo ad esempio caricare dei dati da uno specifico file in R devo fornire il path (o indirizzo) corretto che mi indichi esattamente la posizione del file all’interno della struttura di cartelle del computer. Ad esempio, immaginiamo di avere dei dati My-data.Rda salvato nella cartella Introduction2R nel proprio Desktop.

Desktop/
 |
 |-  Introduction2R/
 |    |
 |    |- Dati/
 |    |   |- My-data.Rda

Per indicare la posizione del File potrei utilizzare un:

absolute path - la posizione “assoluta” del file rispetto alla root directory del sistema ovvero la cartella principale dell’intero computer.

# Mac
"/Users/<username>/Desktop/Introduction2R/Dati/My-data.Rda"

# Windows Vista
"c:\Users\<username>\Desktop\Introduction2R\Dati\My-data.Rda"

relative path - la posizione del file rispetto alla nostra attuale posizione nel computer da cui stiamo eseguendo il comando, ovvero rispetto alla working directory della nostra sessione di lavoro. In questo riprendendo il precedente esempio se la nostra working directory fosse la cartella Desktop/Introduction2R avremmo i seguenti relative path:

# Mac
"Dati/My-data.Rda"

# Windows Vista
"Dati\My-data.Rda"

Nota come sia preferibile l’utilizzo dei relative path poichè gli absolute path sono unici per il singolo computer di riferimento e non possono essere quindi utilizzati su altri computer.

Qualora si utilizzasse un relative path per indicare la posizione di un file, è importante che la working directory attualment in uso sia effettivamente quella prevista. Se ci trovassimo in una divesa cartella, ovviamente il “relative path” indicato non sarebbe più valido e R ci mostrerebbe un messaggio di errore.

Riprendendo l’esempio precedente, supponiamo che la nostra attuale working directory sia Desktop invece di Desktop/Introduction2R. Eseguendo il comadno load() per caricare i dati utilizzando il relative path ora non più valido ottengo:

load("Dati/My-data.Rda")
## Warning in readChar(con, 5L, useBytes = TRUE): cannot open compressed file
## 'Dati/My-data.Rda', probable reason 'No such file or directory'
## Error in readChar(con, 5L, useBytes = TRUE): cannot open the connection

Il messaggio di errore mi indica che R non è stato in grado di trovare il file seguendo le mie indicazioni. E’ come se chiedessi al computer di aprire il frigo ma attualmente si trovasse in camera, devo prima dargli le indicazioni per raggiungere la cucina altrimenti mi risponderebbe “frigo non trovato”. Risulta pertanto fondamentale essere sempre consapevoli di quale sia l’attuale working directory in cui si sta svolgendo la sessione di lavoro.

Ovviamente otterrei lo stesso errore anche usando un absolute path se questo contenesse degli errori.

Come avrai notato dagli esempi precedenti, sia la struttura in cui vengono organizzati i file nel computer sia la sintassi utilizzata per indicare i path è differente in base al sistema operativo utilizzato.

Mac OS e Linux

Il carattere utilizzato per separare le cartelle nella definizione del path è "/":

"Introduction2R/Dati/My-data.Rda"

La root-directory viene indicata iniziando il path con il carattere "/":

"/Users/<username>/Desktop/Introduction2R/Dati/My-data.Rda"

La cartella home dell’utente (ovvero /Users/<username>/) viene indicata iniziando il path con il carattere "~":

"~/Desktop/Introduction2R/Dati/My-data.Rda"

Windows

Il carattere utilizzato per separare le cartelle nella definizione del path è "\":

"Introduction2R\Dati\My-data.Rda"

La root-directory viene indicata con "c:\":

"c:\Users\<username>\Desktop\Introduction2R\Dati\My-data.Rda"

5.2.3 Working Directory in R

Vediamo ora i comandi utilizzati in R per valutare e cambiare la working directory nella propria sessione di lavoro.

Nota negli esempi successivi, come in R il caratere "/" sia sempre utilizzato per separare le cartelle nella definizione del path indipendentemente dal sistema operativo.

Attuale Working Directory

In R è possibile valutare l’attuale working directory utilizzando il comando getwd() che restituirà l’absolute path dell’attuale posizione.

getwd()
## [1] "/Users/<username>/Desktop/Introduction2R"

In alternativa, l’attuale working directory è anche riportata in alto a sinistra della Console come mostrato in Figura 5.5.

Figure 5.5: Workig directory dell’attuale sessione di lavoro

Premendo la freccia al suo fianco il pannello Files in basso a destra sarà reindirizzato direttamento alla workig directory dell’attuale sessione di lavoro. In questo modo sarà facile navigare tra i file e cartelle presenti al suo interno (vedi Figura 5.6).

Figure 5.6: Workig directory dell’attuale sessione di lavoro

Cambiare Working Directory

Per cambiare la working directory è possibile utilizzare il comando setwd() indicando il path (absolute o relative) della nuova working directory. Nota come, nel caso in cui venga indicato un relative path, questo dovrà indicare la posizione della nuova working directory rispetto alla vecchia working directory.

getwd()
## [1] "/Users/<username>/Desktop/Introduction2R"

setwd("Dati/")

getwd()
## [1] "/Users/<username>/Desktop/Introduction2R/Dati"

In alternativa è possibile selezionare l’opzione “Choose Directory” dal menù “Session” > “Set Working Directory” come mostrato in Figura 5.7. Verrà quindi richiesto di selezionare la working directory desiderata e preme “Open”.

Figure 5.7: Definire la working directory

Nota come sia possibile nel digitare il path sfruttare l’autocompletamento. All’interno delle virgolette "" premi il tasto Tab per visualizzare i suggerimenti dei path relativi alla attuale working directory.

E’ possibile inoltre utilizzare i caratteri speciali "./" e "../" per indicare rispettivamente l’attuale working directory e la cartella del livello superiore (i.e., parent folder) che include l’attuale working directory. "../" ci permette quindi di navigare a ritroso dalla nostra attuale posizione tra le cartelle del computer.

getwd()
## [1] "/Users/<username>/Desktop/Introduction2R"

setwd("../")

getwd()
## [1] "/Users/<username>/Desktop/"

5.3 R-packages

Uno dei grandi punti di forza di R è quella di poter estendere le proprie funzioni di base in modo semplice ed intuitivo utilizzando nuovi pacchetti. Al momento esistono oltre 17’000 pachetti disponibili gratuitamente sul CRAN (la repository ufficiale di R). Questi pacchetti sono stati sviluppati dall’immensa comunity di R per svolgere ogni sorta di compito. Si potrebbe dire quindi che in R ogni cosa sia possibile, basta trovare il giusto pacchetto (oppure crearlo!).

Quando abbiamo installato R in automatico sono stati installati una serie di pacchetti che costituiscono la system library, ovvero tutti quei pacchetti di base che permettono il fuzionamento di R. Tuttavia, gli altri pacchetti non sono disponibili da subito. Per utilizzare le funzioni di altri pacchetti, è necessario seguire una procedura in due step come rappresentato in Figura 5.8:

Scaricare ed installare i pacchetti sul nostro computer. I pacchetti sono disponibili gratuitamente online nella reopsitory del CRAN, una sorta di archivio. Vengono quindi scaricati ed installati nella nostra library, ovvero la raccolta di tutti i pacchetti di R disponibili sul nostro computer.
Caricare il paccheto nella sessione di lavoro. Anche se il paccheto è installato nella nostra library non siamo ancora pronti per utilizzare le sue funzioni. Sarà necessario prima caricare il pacchetto nella nostra sessione di lavoro. Solo ora le funzionni del pacchetto saranno effetivamente disponibili per essere usate.

Figure 5.8: Utilizzare i paccheti in R

Questo procedimento in due step potrebbe sembrare poco intuitivo. “Perchè dover caricare qualcosa che è già installato?” La risposta è molto semplice ci serve per mantenere efficiente e sotto controllo la nostra sessione di lavoro. Infatti non avremo mai bisogno di tutti i pacchetti installati ma a seconda dei compiti da eseguire utilizzeremo di volta in volta solo alcuni pacchetti specifici. Se tutti i pacchetti fossero caricati automaticamente ogni volta sarebbe un inutile spreco di memoria e si creerebbero facilmente dei conflitti. Ovvero, alcune funzioni di diversi pacchetti potrebbero avere lo stesso nome ma scopi diversi. Sarebbe quindi molto facile ottenere errori o comunque risultati non validi.

Vediamo ora come eseguire queste operazioni in R.

5.3.1 install.packages()

Per installare dei pacchetti dal CRAN nella nostra library è possibile eseguire il comando install.packages() indicando tra parentesi il nome del pacchetto desiderato.

# Un ottimo pacchetto per le analisi statistiche di John Fox
# un grandissimo statistico...per gli amici Jonny la volpe ;)
install.packages("car")

In alternativa è possibile utilizzare il pulsante “Install” nella barra in alto a sinistra del pannello Packages ( vedi Figura 5.9), indicando successivamente il nome del pacchetto desiderato.

Figure 5.9: Installare paccektti tramite interfacci RStudio

Nota come installare un pacchetto potrebbe comportare l’installazione di più pacchetti. Questo perchè verranno automaticamente installate anche le dependencies del pacchetto, ovverro, tutti i pacchetti usati internamente dal pacchetto di interesse che quindi necessari per il suo corretto funzionaemnto (come in un gioco di matrioske).

Una volta installato il pacchetto, questo comarirà nella library ovvero la lista dei pacchetti disponibili mostrata nel pannello Packages (vedi Figura 5.10).

Figure 5.10: Il pacchetto car è ora disponibile nella library

Nell’installare dei pacchetti, potrebbe accadere che R presenti un messaggio simile al seguente:

There are binary versions available but the
  source versions are later:
           binary source needs_compilation
devtools   1.13.4  2.0.1             FALSE
    [... una lista di vari pacchetti...]

Do you want to install from sources the packages which need compilation?

In breve, la risposta da dare è NO ("n"). Ma che cosa ci sta effetivamente chiedendo R? Esistono diversi modi in cui un pacchetto è disponibile, tra i principali abbiamo:

Versione Binary - pronta all’uso e semplice da installare
Versione Source - richiede una particolare procedura per essere installata detta compilazione

In genere quindi, è sempre preferibile installare la versione Binary. Tuttavia, in questo caso R ci avverte che, per alcuni pacchetti, gli aggiornameni più recenti sono disponibili solo nella versione Source e ci chiede quindi se installarli attraverso la procedura di compilazione.

E’ preferibile rispondere “no”, installando così la versione Binary pronta all’uso anche se meno aggiornata. Qualora fosse richiesto obbligatoriamente di installare un pacchetto nella version Source (perchè ci servono gli ultimi aggiornamenti o perchè non disponibile altrimenti) dovremmo avere prima installato R tools (vedi “Approfondimento: R Tools” nel Capitolo 1.1), che ci fornirà gli strumenti necessari per compilare i pacchetti.

Per una discussione dettagliata vedi https://community.rstudio.com/t/meaning-of-common-message-when-install-a-package-there-are-binary-versions-available-but-the-source-versions-are-later/2431 e https://r-pkgs.org/package-structure-state.html

5.3.2 library()

Per utilizzare le funzioni di un pacchetto già presente nella notra library, dobbiamo ora caricarlo nella nostra sessione di lavoro. Per fare ciò, posssiamo utilizzare il comando library() indicando tra parentesi il nome del pacchetto richiesto.

library(car)

In alternativa è possibile spuntare il riquadro alla sinistra del nome del pacchetto dal pannello Packages come mostrato in Figura 5.11. Nota tuttavia come questa procedura sia sconsigliata. Infatti, ogni azione punta-e-clicca dovrebbe essere eseguita ad ogni sessione mentre l’utilizzo di comandi inclusi nello script garantisce la loro esecuzione automatica.

Figure 5.11: Caricare un pacchetto nella sessione di lavoro

Ora siamo finalmente pronti per utilizzare le funzioni del pacchetto nella nostra sessione di lavro.

Esiste un piccolo trucco per utilizzare la funzione di uno specifico pacchetto senza dover caricare il pacchetto nella propria sessione. Per fare questo è possibile usare la sintassi:

<nome-pacchetto>::<nome-funzione>()

# Esempio con la funzione Anova del pacchetto car
car::Anova()

L’utilizzo dei :: ci permette di richiamare direttamente la funzione desiderata. La differennza tra l’uso di library() e l’uso di :: riguarda aspetti abbastanza avanzati di R (per un approfondimento vedi https://r-pkgs.org/namespace.html). In estrema sintesi, possiamo dire che in alcuni casi è preferibile non caricare un’intero pacchetto se di questo abbiamo bisogno di un’unica funzione.

5.3.3 Aggiornare e Rimuovere Pacchetti

Anche i pacchettti come ogni altro software vengono aggiornati nel corso del tempo fornendo nuove funzionalità e risolvendo eventuli problemi. Per aggiornare i pacchetti alla versione più recente è possibile eseguire il comando update.packages() senza inidare nulla tra le parentesi.

In alternativa è possibile premere il pulsante “Update” nella barra in alto a sinistra del pannello Packages ( vedi Figura 5.12), indicando successivamente i pachetti che si desidera aggiornare. Nota come nella lista dei pacchetti venga riportata l’attuale versione alla voce “Version”.

Figure 5.12: Aggiornare i pacchetti

Nel caso in cui si vogli invece rimuover uno specifico pacchetto, è possibile eseguire il comando remove.packages() indicando tra le parentesi il nome del pacchetto.

In alternativa è possibile premere il pulsante x alla destra del paccehettto nel pannello Packages come mostrao in Figura 5.13.

Figure 5.13: Rimuovere un pacchetto

5.3.4 Documentazione Pacchetti

Ogni pacchetto include la documentazione delle proprie funzioni e delle vignette ovvero dei brevi tutorial che mostrano degli esempi di applicazione e utilizzo del pacchetto.

Documentazione funzione - Per accedere alla documentazione di una funzione è sufficiente utilizzare il comando ?<nome-funzione> oppure help(<nome-funzione>). Ricorda è necessario avere prima caricato il pacchetto altrimenti la funzione non risulta ancora disponibile. In alternativa si potrebbe estendere la ricerca utilizzando il comando ??.
Vignette - Per ottenere la lista di tutte le vignette di un determinato pacchetto è possibile utilizzare il comando browseVignettes(package = <nome-pacchetto>)'. Mentre, per accedere ad una specifica vignetta, si utilizza il comando vignette("<name-vignetta>").
Documentazione intero pacchetto - Premendo il nome del pacchetto dal pannello Packages in basso a destra, è possibile accedere alla lista di tutte le informazioni relative al pacchetto come riportato in Figura 5.14. Vengono prima forniti i link per le vignette ed altri file relativi alle caratteristiche del pacchetto. Successivamente sono presentate in ordine alfabetico tutte le funzioni.

Figure 5.14: Documetazione del pacchetto car

Ricordate tuttavia che in ogni caso la più grande risorsa di informazioni è come sempre google. Spesso i pacchetti più importanti hanno addirittura un proprio sito in cui raccolgono molto materiale utile. Ma comunque in ogni caso in internet sono sempre disponibili moltissimi tutorial ed esempi.

Il CRAN non è l’unica risorsa da cui è possibile installare dei pacchetti di R tuttavia è quella ufficiale e garantisce un certo standard e stabilità dei pacchetti presenti. In internet esistono molte altre repository che raccolgono paccetti di R (e software in generale) tra cui una delle più popolari è certamente GitHub (https://github.com/).

Github viene utilizzato come piattaforma di sviluppo per molti pacchetti di R ed è quindi possibile trovarve le ultime versioni di sviluppo dei pacchetti con gli aggirnamenti più recenti o anche nuovi pacchetti non ancora disponibili sul CRAN. Va sottolineato tuttavia, come quete siano appunto delle versioni di sviluppo e quindi potrebbero presentare maggiori problemi. Inoltre per installare i pacchetti in questo modo, è richiesta l’installzione di R tools (vedi “Approfondimento: R Tools” nel Capitolo 1.1).

Per installare un pacchetto direttamente da Github è posibile utilizzare il comando install_github() del pacchetto devtools, indicanto tra parentesi la l’url della repository desiderata.

install.packages("devtools")

# ggplot2 il miglior pacchetto per grafici
devtools::install_github("https://github.com/tidyverse/ggplot2")