analisi delle differenze strutturali nelle espressioni regolari costruite da programmatori e da...

Universita degli Studi di Trieste

DIPARTIMENTO DI INGEGNERIA E ARCHITETTURA

Corso di Laurea Triennale in Ingegneria dell’Informazione

Analisi delle differenze strutturali nelle espressioni regolaricostruite da programmatori e da strumenti automatici

Relatore

Prof. Alberto Bartoli

Correlatore

Prof. Eric Medvet

Laureando

Marco Potok

Anno Accademico 2014-2015

Indice

1 Introduzione 1

2 Metodo di analisi 32.1 Dati iniziali . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32.2 Struttura delle espressioni regolari . . . . . . . . . . . . . . . . 4

2.2.1 Lunghezza . . . . . . . . . . . . . . . . . . . . . . . . . 42.2.2 Blocchi base . . . . . . . . . . . . . . . . . . . . . . . . 4

2.3 Preprocessing dei dati . . . . . . . . . . . . . . . . . . . . . . 6

3 Risultati e analisi 133.1 Lunghezza delle espressioni . . . . . . . . . . . . . . . . . . . . 133.2 Uso dei blocchi nelle espressioni . . . . . . . . . . . . . . . . . 183.3 Divisione task per difficolta . . . . . . . . . . . . . . . . . . . 22

4 Conclusioni 27

3

4 INDICE

Capitolo 1

Introduzione

Con questo elaborato s’intende analizzare la struttura di espressioni rego-lari costruite da strumenti automatici e confrontarla con espressioni regolaricostruite da programmatori. Le espressioni regolari o regex (abbreviazionedall’inglese regular expression) sono delle sequenze di caratteri che individua-no un pattern all’interno, per esempio, di un testo. Lo strumento automaticoche ha generato le regex che si andranno ad analizzare e il RegexGenera-tor++[1], sviluppato presso il Machine Learning Lab[2] presente all’internodell’Universita degli Studi di Trieste.

Per un programmatore scrivere un’espressione regolare spesso risulta com-plicato, per cui generare automaticamente un’espressione di buona qualita sitraduce in risparmio di tempo con risultati piu precisi ed accurati1. Il finedi questa analisi e quindi caratterizzare i punti deboli e i punti di forza delleespressioni costruite automaticamente, in modo da migliorarne l’efficacia econtenerne la lunghezza.

Il lavoro descritto in questo documento ha evidenziato come la macchinacostruisca delle espressioni con una struttura compatibile a quelle umane. Lafrequenza di utilizzo di alcuni blocchi base delle espressioni e pero diversa,specialmente dove i pattern da individuare risultano piu irregolari. In questicasi le regex macchina tendono ad allungarsi e diventare piu complicate.

Il lavoro e stato costituito da queste fasi chiave:

1. Elaborazione dei dati forniti dal laboratorio e generazione di grafici2. Analisi dei grafici ottenuti

1S’intende la capacita dell’espressione di individuare tutte e sole le sequenze di caratterivolute

1

2 CAPITOLO 1. INTRODUZIONE

Il solo software utilizzato in tutte le fasi dell’analisi e stato RStudio, am-biente di sviluppo integrato per il linguaggio R. Tutto il codice riportato inquesto elaborato e stato prodotto dall’autore, cosı come tutti i grafici.

I capitoli successivi affronteranno il lavoro suddiviso in:1. descrizione della composizione delle espressioni regolari e dei dati ini-

ziali in possesso2. descrizione del codice prodotto per elaborare i dati iniziali e per genera-

re i grafici richiesti, analisi dei grafici ottenuti e considerazioni riguardola qualita delle regex macchina

3. conclusioni

Capitolo 2

Metodo di analisi

Per analizzare le espressioni regolari da un punto di vista strutturale sisono adottati due metodi. Il primo consiste semplicemente nel calcolare lalunghezza di ogni espressione generata dalla macchina. Il secondo metodoconsiste nello scomporre ogni regex in blocchi base o building block e verificarein che percentuale vengono utilizzati. Ogni risultato viene poi confrontatotramite dei grafici con i risultati ottenuti dai dati relativi alle espressionicostruite da programmatori per i medesimi compiti.

2.1 Dati iniziali

I dati iniziali sono stati forniti dal Machine Learning Lab dell’Universitadegli Studi di Trieste all’autore dell’elaborato. Il set e composto da 9842campioni generati da 1724 umani e 12000 campioni generati dalla macchina.I dati sono stati ottenuti facendo svolgere gli stessi 9 task ai due tipi di utente.Ogni task prevede la scrittura di un’espressione regolare che individui uncerto tipo di stringa:

1. Log-MAC: indirizzi MAC (Ethernet) in un testo

2. Cetinkaya-Text-All-URL: indirizzi URL in un testo

3. Log-IP: indirizzi IP in un testo

4. Cetinkaya-HTML-HREF: attributo href in un documento HTML

5. ReLIE-HTML-All-URL: inidirizzi URL in un documento HTML

6. Web-HTML-Heading: attributo header in un documento HTML

7. ReLIE-Email-Phone-Number: email e numeri telefonici in un testo

3

4 CAPITOLO 2. METODO DI ANALISI

8. Bibtex-Author: autori in un documento Bibtex

9. Web-HTML-Heading-Content: contenuto dell’header in un docu-mento HTML

Ogni espressione presenta dei tag associati che permettono di classificarla.I tag in questione sono:

• User: identifica l’autore della regex e puo essere Human, Machine,Machine first gen1, Machine last gen2.

• Skill: indica l’esperienza dell’User nello scrivere espressioni regolari epuo essere Experienced, Intermediate, Novice, Machine, Machine firstgen o Machine last gen

• Level: indica a che task fa riferimento l’espressione

2.2 Struttura delle espressioni regolari

2.2.1 Lunghezza

La lunghezza e il numero di caratteri che compongono un’espressione. Eintuitivo capire che lavorare con delle regex corte e meglio che lavorare conregex molto lunghe e complesse. La lunghezza non e un indice diretto dellafitness di una regex ma e importante per individuare eventuali difficolta nellagenerazione dell’espressione.

2.2.2 Blocchi base

I blocchi base sono delle sequenze fondamentali di caratteri che combinateassieme formano le regex. Al fine dell’analisi sono stati considerati settediversi tipi di blocchi:

• Classi:

– \w: individua tutte le lettere e cifre

– \d: individua tutte le cifre

– [A-Z]: individua tutte le lettere maiuscole

– [a-z]: individua tutte le lettere minuscole

1Significa che l’espressione e appartentente alla prima generazione nell’evoluzione dellastessa.

2L’espressione in questo caso e appartenente all’ultima generazione.

2.2. STRUTTURA DELLE ESPRESSIONI REGOLARI 5

– [A-Za-z]: individua tutte le lettere minuscole e maiuscole

• Classi negate:

– \W: individua tutti i simboli che non siano lettere o cifre

– \D: individua tutti i simboli che non siano cifre

– [Â-Z]: individua tutti i simboli che non siano lettere maiuscole

– [â-z]: individua tutti i simboli che non siano lettere minuscole

– [Â-Za-z]: individua tutti i simboli che non siano lettere minu-scole e/o maiuscole

• Classi custom: individuano un gruppo di caratteri definito dal pro-grammatore. E delimitato da due parentesi quadre e contiene qualsiasialtro blocco. Sono ovviamente esclusi i casi equivalenti alle classi eclassi negate

• Quantificatori: Vengono posti alla fine di un altro blocco e indicanoquante volte lo stesso puo comparire.

– +: il blocco precedente puo comparire 1 o piu volte

– *: il blocco precedente puo comparire 0 o piu volte

– {1,3}: il blocco precedente puo comparire da 1 a 3 volte

– {3}: il blocco precedente puo comparire esattamente 3 volte

– {3,}: il blocco precedente puo comparire 3 o piu volte

– ?: il blocco precedente puo comparire 0 o 1 volta

Ogni quantificatore puo essere utilizzato nella forma greedy, reluctanto possesive. La macchina usa solo quest’ultima forma.

• Lookaround: Vengono posti alla fine di un altro blocco e specificanoi simboli che devono o non devono comparire prima o dopo il gruppoindividuato.

– (?=<blocco>): il gruppo deve essere seguito dal blocco

– (?!<blocco>): il gruppo non deve essere seguito dal blocco

– (?<=<blocco>): il gruppo deve essere preceduto dal blocco

– (?<!<blocco> il gruppo non deve essere preceduto dal blocco

• Backreference: Poste alla fine di un altro blocco, specificano chegruppo precedente deve essere ripetuto. Sono del tipo \3, e questa inparticolare richiede che alla fine sia ripetuto il terzo blocco.


• Costanti: Le costanti sono rappresentate da tutto cio che non rientranei gruppi precedenti. Individuano lo stesso gruppo di caratteri di cuisono composte. Ad esempio http:// individuera proprio la sequenzadi caratteri http://.

Per maggiori approfondimenti si veda [3].

2.3 Preprocessing dei dati

Per l’analisi dei dati si e deciso di rappresentarli mediante dei grafici. Trale possibili opzioni sono strati scelti tre tipi di rappresentazioni grafiche:

1. Grafico delle densita

2. Diagramma box and whiskers

3. Diagramma a colonne

Le opzioni 1 e 2 si vogliono utilizzare per visualizzare i dati relativi allalunghezza, mentre l’opzione 3 per i dati relativi alla distribuzione di buildingblock. Inoltre si e ritenuto opportuno rappresentare i grafici differenziandoliper

- User

- Skill

- User e Lever

- Skill e Level

in modo da evidenziare le differenze nei vari aspetti.Si e quindi optato per utilizzare la libreria ggplot2 [4] che offre la possibi-

lita di creare i grafici voluti con poche righe di codice. Dopo uno studio delladocumentazione della libreria [5] sı e deciso di costruire dei data frame speci-fici in modo da poter inserire i dati iniziali nella funzione ggplot dell’omonimalibreria.

I dati iniziali sono stati importati nell’IDE RStudio e sono stati convertitiin data frame, strutture dati specifiche del linguaggio R equivalenti a matrici.Come primo passo, per l’analisi della lunghezza, e stato creato un data framecomposto dalle colonne User, Skill, Level e Regex, con l’ultima contenentela lunghezza dell’espressione regolare. In seguito e stato creato un secondodata frame per analizzare l’utilizzo dei building block, composto quindi dalle

2.3. PREPROCESSING DEI DATI 7

colonne User, Skill, Level e Type, dove l’ultima colonna contiene il tipo diblocco.

Partendo da un data frame contenente le stringe delle regex si e volu-to sostituire il contenuto della colonna Regex con il valore della lunghezzadell’espressione. Per questo compito il codice utilizzato risulta:

for (i in 1:nrow(data.frame)){

data.frame$regex = nchar(as.character(data.frame$regex))

}

Il data frame ottenuto e quindi nella forma

User Skill Level Regex1 Machine first gen Machine first gen Log-IP 212 Human Intermediate Log-MAC 433 ... ... ... ...

Tabella 2.1: Struttura di data.frame

pronto per essere inserito nel comando ggplot.Sempre dal data frame dei dati iniziali si e voluto crearne uno che conte-

nesse le informazioni su quanti building block di un certo tipo sono presenti inogni regex. Per individuare i blocchi si e deciso di utilizzare la libreria stringi[6]. Di questa libreria si e utilizzato il comando stri_count_regex(<stringa>, <regex>),dove regex rappresenta l’espressione regolare che individua un tipo di blocconella sequenza di caratteri stringa. Si sono quindi create sette espressioniregolari, una per ogni building block:

lookaround = "\$\\?\\=|\\(\\?\\!|\\(\\?\\<\\=|\\(\\?\\<\\!

|\\(\\?\\:.+\$"

quantifier = "[*?+][+?]?|\\{\\d+\\,?\\d*\\}"

classes = "\\[(A-Z|a-z|A-Za-z)\\]|\\\\w|\\\\d"

customclasses = "\\[\\w[^\\]\\^\\-]+\\]"

negatedclasses = "\\[\\^[^\\[\\]\\-]+\\]|\\\\D|\\\\W"

backrefenreces = "(\\\\\\d)"

constants = "(\\\\\\d)|\\[([^\\]]+)\\]|\\\\w|\\\\W|\\\\D

|\\\\s|\\\\S|\\\\d| \\++|(\$\\?\\:)|(\\(\\?\\=)|(\\(\\?\\!)

|(\\(\\?\\<\\=)|(\\(\\?\\<\\!)|\$|\\(|\\?|\\*

|\\{\\d+\\,?\\d*\\}|\\[|\\]|[^\\\\]\\."

countConstants = "[^£]+"


Si noti che per calcolare le costanti si e optato di inserire, con l’ausilio delcomando stri_replace_all_regex, il placeholder £ al posto ogni blocco chenon rappresenti una costante. In seguito si e proceduto con il conteggio comeper gli altri building block.

dataWithBlocks = data.frame()

for (i in 1:nrow(regex.play)) {

t = regex.play[i,]

r = t[1,4]

t$loockaround = stri_count_regex(r, lookaround)

t$quant = stri_count_regex(r, quantifier)

t$class = stri_count_regex(r, classes)

t$customClass = stri_count_regex(r, customclasses)

t$negatedClass = stri_count_regex(r, negatedclasses)

t$backReferences = stri_count_regex(r, backrefenreces)

t$constant = stri_replace_all_regex(r,constants, "£")

t$constant = stri_count_regex(r, countConstants)

dataWithBlocks = rbind(dataWithBlocks, t)

}

Per inserire i dati correttamente nella funzione ggplot si e dovuto creareun altro data frame con una sola colonna dove fosse contenuto il nome delblocco. In questo nuovo data frame piu righe posso essere relative alla stessaespressione regolare ed e nella forma indicata nella tabella 2.2.

User Skill Level Type1 Human Intermediate 2 Class2 Human Intermediate 2 Constant3 Machine last gen Machine last gen 5 Negated Class4 ... ... ... ...

Tabella 2.2: Struttura del data frame dataBB

Il codice utilizzato e:

user = c()

skill = c()

level= c()

type = c()


for (i in 1:nrow(dataWithBlocks)) {

t = dataWithBlocks[i,]

tUser = t$User

tSkill = t$skill

tLevel = t$level

la = t$lookaround

q = t$quant

c = t$class

cc = t$customClass

nc = t$negatedClass

bf = t$backReferences

cn = t$constant

index = 1

while (index <= la) {

user = append(user,tUser )

skill = append(skill, as.character(tSkill))

level = append(level,tLevel )

type = append(type,"lookaround")

index = index + 1

}

index = 1

while (index <= q) {

user = append(user, tUser)


level = append(level, tLevel)

type = append(type, "quantifier")

index = index + 1

}

index = 1

while (index <= c) {




type = append(type,"class")

index = index + 1


}

index = 1

while (index <= cc) {




type = append(type, "customClass")

index = index + 1

}

index = 1

while (index <= nc) {




type = append(type, "negatedClass")

index = index + 1

}

index = 1

while (index <= bf) {




type = append(type, "backReferences")

index = index + 1

}

index = 1

while (index <= c) {




type = append(type,"constant")

index = index + 1

}

}

dataBB = data.frame(user,skill, level, type)


A questo punto i data frame dei dati iniziali risultano compatibili con lefunzioni della libreria ggplot con le quali si vuole creare i grafici per l’analisi.Nel prossimo capitolo saranno esposti i grafici e il procedimento per ottenerli.

Capitolo 3

Risultati e analisi

In questo capitolo vedremo che codice e stato scritto per la generazionedei grafici e i grafici stessi, descrivendo cio che e stato ottenuto.

3.1 Lunghezza delle espressioni

Preso il data frame descritto nella tabella 2.1, per prima cosa si e volutodisegnare un grafico che rappresenti la densita di regex con una certa lun-ghezza divisa per User. Da notare che in tutti i grafici l’asse delle ascisse ein scala logaritmica.

La figura 3.1 mostra come la lunghezza delle espressioni e distribuita intutti i nove task divisa per utente, ovvero Machine e Human. Il grafico egenerato dal codice

# Human vs Machine regex length

ggplot(dataGenLength, aes(x=regex, fill=User,

title = "Human vs Machine regex length")) +

geom_density(alpha = .33) +

labs(x = "Regex length") +

scale_x_log10() +

facet_wrap(~ level)

13

14 CAPITOLO 3. RISULTATI E ANALISI

Figura 3.1: Human vs Machine regex length

Da questa prima figura si possono formulare le prime considerazioni ri-guardo le differenze tra gli utenti. Caratteristiche delle espressioni generatedall’utente Machine:

• Presentano un evidente picco in corrispondenza di una lunghezza di10-11 caratteri

• Non presentano una lunghezza minore di 9-10 caratteri

• Sono in quantita moderata, ma pur sempre apprezzabile, piu lunghe di30-40 caratteri

Caratteristiche delle espressioni generate dall’utente Human:

• La maggior parte presenta una lunghezza compresa tra i 15 e 30 carat-teri

• Sono di lunghezza 1-9 caratteri in quantita apprezzabile

• Generalmente non superano i 40 caratteri di lunghezza

Poiche i programmatori che hanno costruito le espressioni in esame eranodi differenti esperienze, si e deciso di riproporre il grafico densita-lunghezzaregex dividendo i dati per abilita. Il grafico risultante e riportato nella figura3.2 ed e stato generato eseguendo il codice

3.1. LUNGHEZZA DELLE ESPRESSIONI 15

# Regex length by skill

ggplot(dataWithLength, aes(x=regex, fill=skill,

title = "Regex length by skill")) +

geom_density(alpha = .25) +

scale_x_log10() +

labs(x = "Regex length") +

facet_wrap(~ level)

Figura 3.2: Skill regex length

Si noti come i tre diversi tipi di esperienza non presentino una grande discre-panza nei grafici, anche se l’utente Human Novice tende a costruire regex piucorte. Questo risultato pero e probabilmente causato dalla poca esperienzae quindi scarsa qualita delle espressioni.



Per una valutazione della lunghezza nei diversi task, si e quindi generatouna tabella di 9 grafici, uno per ogni compito. Analizzando la figura 3.3 sipossono fare le seguenti considerazioni:

• Nei task 1 - 6 la macchina genera regex nettamente piu corte rispettoai programmatori

• Nei task 7 - 9 la macchina tende a generare regex piu lunghe rispettoai programmatori

Notato questo andamento, si e deciso di considerare non solo la generazionefinale delle espressioni regolari ma la tendenza ad accorciarle o allungarledurante l’evoluzione.

Quindi e stato rigenerato il grafico lunghezza - densita dividendo i campio-ni dell’utente macchine in Machine first gen e Machine last gen. Il risultato,visualizzabile nella figura 3.4 mostra come la tendenza generale e di accorcia-re le espressioni durante l’evoluzione. La tendenza evidenziata nella figura3.4, viene confermata analizzando la figura 3.5. In questo caso i grafici sonodel tipo box and whiskers, dove i rettangoli sono delimitati dal primo e terzoquartile, la linea all’interno rappresenta il secondo quartile o mediana [7].

3.1. LUNGHEZZA DELLE ESPRESSIONI 17

Figura 3.4: Generation regex length



3.2 Uso dei blocchi nelle espressioni

Come fatto per l’analisi della lunghezza, il primo passo e stato quello digenerare un grafico distinguendo i dati in base all’utente Human o Machine.Si e quindi scritto ed eseguito il codice

# Building Blocks usage - Percentage

ggplot(dataBB, aes(x=user, fill=type,

title = "Building Blocks usage - Percentage")) +

geom_bar(position = "fill") +

labs(y = "percentage")

ottenendo come risultato il grafico 3.6.


Si nota come sia evidente la differenza nell’utilizzo delle costanti e delleclassi tra i due utenti, mentre per gli altri tipi di blocchi le differenze sonomeno marcate.

Una prima considerazione del risultato si puo riassumere in:

• L’utente macchina usa piu

– Classi (rilevante)

– Classi negate

3.2. USO DEI BLOCCHI NELLE ESPRESSIONI 19

• L’utente programmatore usa piu

– Costanti (rilevante)

– Backreference

– Classi custom

• Gli utenti usano con frequenza simile

– Quantificatori

– Lookaround

Si procede con la generazione dei grafici relativi ai dati divisi per utentee task. Eseguendo il codice

# Building Blocks usage - Percentage

ggplot(dataBB, aes(x=user, fill=type,

title = "Building Blocks usage - Percentage")) +


labs(y = "percentage") +

facet_wrap(~ level)

si ottiene la figura 3.7. L’andamento nei diversi compiti e confermato a menodi qualche eccezione, dove la percentuale di classi nelle espressione dei dueutenti sono simili. Considerando anche le classi negate (che presentano unastruttura e lunghezza simile alle classi ”semplici”), l’uso totale delle classi esempre in percentuale maggiore per le regex relative all’utente Machine.

Si e quindi analizzato l’andamento durante l’evoluzione delle espressio-ni prodotte dallo strumento automatico descritto nella figura 3.8, generatadall’esecuzione del codice

# Building Blocks Generation Usage

ggplot(dataBBGenH, aes(x=user, fill=type,

title = "Building Blocks Generation Usage")) +


labs(y = "percentage")

Si e mantenuta la barra verticale relativa all’utente Human come riferimento.Tra la prima e l’ultima generazione notiamo che:

• le classi diminuiscono

• i lookaround aumentano moderatamente

• le classi negate aumentano



• i quantificatori rimangono invariati

• le costanti aumentano moderatamente

La somma delle classi e classi negate, che generalmente danno maggior con-tributo alla lunghezza delle espressioni, nel complesso diminuisce, lasciandospazio alle costanti. Questa tendenza sembra limare le differenze nell’uso inpercentuale dei blocchi tra i due utenti.

Per concludere sono stati generati i grafici relativi ai blocchi divisi pertask, distinguendo sempre tra prima e ultima generazione. Con l’esecuzionedel codice

# Building Blocks Generation Usage

ggplot(dataBBGenH, aes(x=user, fill=type,

title = "Building Blocks Generation Usage")) +


labs(y = "percentage") +

facet_wrap(~ level)

si e prodotta la figura 3.9.

3.2. USO DEI BLOCCHI NELLE ESPRESSIONI 21




3.3 Divisione task per difficolta

I nove task sono stati suddivisi in due gruppi

• Task facili per la macchina

– Log-MAC

– Cetinkaya-Text-All-URL

– Log-IP

– Cetinkaya-HTML-HREF

– ReLIE-HTML-All-URL

• Task difficili per la macchina

– Web-HTML-Heading

– ReLIE-Email-Phone-Number

– Bibtex-Author

– Web-HTML-Heading-Content

Di questi due gruppi di task son stati generati i grafici, analizzando lunghezzaed uso dei building block. Da una prima analisi della figura 3.10 si notasubito che la macchina tende a generare regex piu corte rispetto agli umaninel primo gruppo e piu lunghe rispetto agli umani nel secondo gruppo.

Utilizzando i box-plot e distinguendo tra regex della prima generazione eultima generazione (figura 3.11), si puo notare inoltre che:

• Nel primo gruppo il valore della mediana tende a diminuire nel passag-gio tra la prima e l’ultima generazione di regex macchina. Inoltre talevalore e inferiore rispetto a quello relativo alle regex umane.

• Nel secondo gruppo il valore della mediana tende ad aumentare nelpassaggio tra la prima e l’ultima generazione di regex macchina, fino arisultare maggiore di quello relativo alle regex umane

E possibile apprezzare queste tendenze tra la prima e l’ultima generazioneanche guardando il grafico delle densita 3.12.

Per un’analisi relativa ai building block si e generato il grafico rappresen-tato nella figura 3.13. Si puo affermare che:

1. Nel gruppo dei task difficili la macchina usa in percentuale meno co-stanti e piu classi, anche se la tendenza nell’evoluzione e simile tra idue gruppi, e consiste in un leggero aumento di costanti, quantificatorie lookaround, un aumento apprezzabile di classi negate (specialmenteper i task difficili) ed una diminuzione delle classi.

3.3. DIVISIONE TASK PER DIFFICOLTA 23


2. Rispetto agli umani, la macchina usa molte meno costanti e molte piuclassi (sia semplici che negate), mentre la quantita di quantificatori elookaround usati e in linea tra le due entita.

Sembra quindi che la macchina usi molte classi a discapito delle costanti. Efacile capire che la lunghezza delle classi e delle classi negate e in media piugrande di quella delle costanti, il che comporta un aumento generale dellalunghezza delle regex. Questa tendenza si amplifica quando la macchinae di fronte ad un task difficile. Si e voluto anche verificare un’eventualecorrelazione tra f-measure e lunghezza delle regex ma tale analisi non haportato ad un risultato significativo.

3.3. DIVISIONE TASK PER DIFFICOLTA 25


Capitolo 4

Conclusioni

In conclusione si puo affermare che lo strumento automatico e in grado digenerare delle espressioni regolari piuttosto corte e generalmente di lunghezzaminore rispetto a quelle costruite dai programmatori. Tuttavia lo studio hariscontrato una certa generalizzazione delle regex macchina in certi task dovele stringhe da individuare presentano un pattern poco regolare. Infatti perquesti compiti lo strumento automatico predilige l’uso di classi, sia sempliciche negate, a discapito delle costanti, provocando un aumento nella lunghezzadelle espressioni.

Un possibile sviluppo futuro a partire da questo studio e procedere l’in-dividuazione delle caratteristiche dei task che causano un aumento della lun-ghezza delle espressioni. Inoltre potrebbe essere interessante un’analisi piuapprofondita su un’eventuale correlazione tra lunghezza, uso dei blocchi basee f-measure delle espressioni regolari.

27

28 CAPITOLO 4. CONCLUSIONI

Bibliografia

[1] Machine Learning Lab. Regex Generator++. 2015. url: http://regex.inginf.units.it (visitato il 16/02/2016).

[2] Machine Learning Lab. Machine Learning Lab. 2015. url: {http://machinelearning.inginf.units.it/} (visitato il 16/02/2016).

[3] The gskinner team Grant Skinner. RegExr v2.1. 2015. url: http://regexr.com/ (visitato il 16/02/2016).

[4] Hadley Wickham. ggplot2. 2013. url: http://ggplot2.org/ (visitatoil 16/02/2016).

[5] Winston Chang Hadley Wickham. ggplot2 2.0.0 docs. 2013. url: http://docs.ggplot2.org/current/ (visitato il 16/02/2016).

[6] Bartek Tartanus Marek Gagolewski. stringi: Character String ProcessingFacilities. 2015. url: https://cran.r-project.org/web/packages/stringi/index.html (visitato il 16/02/2016).

[7] Wikipedia. Box-plot. 2014. url: https://en.wikipedia.org/wiki/Box_plot (visitato il 19/02/2016).

29

analisi delle differenze strutturali nelle espressioni regolari costruite da programmatori e da...

Engineering