Tabulazioni o spazi per il rientro? Statistiche per 3.8 milioni di Perl file creati per 24 anni

Uno dei annosa questione in programmazione — quali sono i caratteri utilizzati nel codice di un programma per il rientro — tabulazioni o spazi.

A volte non c'è scelta. Ad esempio, in Makefile è necessariamente bisogno di utilizzare le tabulazioni. In lingua programmazione go c'è un ufficiale di utilità gofmt che formatta il codice e questa utility utilizza taba per il rientro. B esoterico linguaggio di programmazione Whitespace taba e le lacune non è possibile sostituire l' altro. Ma molti linguaggi di programmazione non impongono una scelta, ma consentono al programmatore di decidere quali personaggi usare.

C'è abbastanza popolare parere quali sono i caratteri da utilizzare per il rientro. Parere i seguenti: non è importante cosa usare, soprattutto консистентность. Se usi taba, allora avete bisogno sempre di usarli. Se usi degli spazi, è necessario utilizzare solo gli spazi e non usare le tabulazioni.

C'è anche un comico comico comico sul tema:

(due persone completamente d'accordo con l'altro se si desidera utilizzare taba o lacune, ma sono assolutamente d'accordo che è necessario utilizzare solo una cosa):

E come vanno le cose nel mondo reale? Che in realtà viene utilizzato?

È abbastanza semplice da capire. È necessario prendere i codici sorgente dei programmi, contare quali sono i caratteri utilizzati e vedere i risultati.

Questo articolo è il risultato di un piccolo studio circa l'uso di schede e spazi nel mondo del linguaggio di programmazione Perl. C'è un enorme archivio in cui sono conservati Perl libreria — CPAN. Ho scaricato tutte le versioni di tutte le librerie che ora ci sono su CPAN (loro si è rivelato di circa 135 mila) e ha ritenuto i caratteri che viene utilizzato per il rientro.

Prima di leggere oltre, mi offro per un attimo a riflettere e provare supporre che il più popolare per il rientro:

  • taba
  • spazi
  • o una miscela di schede e spazi

?

La scrittura di codice

Quindi, la sfida è chiara. È necessario prendere tutte le librerie con CPAN e verificare che viene utilizzato per di rientro.

Per cominciare, è necessario scaricare l'intero CPAN. Questo viene fatto con l'aiuto di una squadra:

time /usr/bin/rsync -av --delete cpan-rsync.perl.org::CPAN /project/CPAN/

3 ore e CPAN scaricata. Ci vogliono circa 27 GB.

CPAN è un insieme di file che sono organizzati in una struttura. Ecco un frammento:

CPAN/authors/id
├── A
│   ├── AA
│   │   ├── AADLER
│   │   │   ├── CHECKSUMS
│   │   │   ├── Games-LogicPuzzle-0.10.readme
│   │   │   ├── Games-LogicPuzzle-0.10.tar.gz
│   │   │   ├── Games-LogicPuzzle-0.12.readme
│   │   │   ├── Games-LogicPuzzle-0.12.tar.gz

In questo esempio AADLER è il login dell'autore, e Games-LogicPuzzle-0.10.tar.gz e Games-LogicPuzzle-0.12.tar.gz — questa release.

Ora su CPAN ci sono più di 7 mila gli autori che hanno scaricato le librerie su CPAN. Per non memorizzare tutti i 7 mila cartelle in una cartella, aggiunto ancora un paio di livelli (sistema di controllo delle versioni git memorizza i dati in modo simile).

Su CPAN è possibile caricare le librerie, raggruppate in diversi programmi.

Ho iniziato con quello che ritenevo il numero di diverse estensioni di file nella cartella CPAN/authors/id/. Ecco lo script e il risultato del suo lavoro . Top estensioni di archivio:

  • .tar.gz 135571
  • .tgz 903
  • .zip 652
  • .gz 612
  • .bz2 243

.tar.gz vince con questo scarto, che ho deciso che sarà sufficiente contare quali sono i caratteri utilizzati in ritirata solo nelle biblioteche, raggruppate in .tar.gz

Sopra ho scritto un paio di script. Inizialmente non me fino alla fine è stato chiaro in quale forma voglio ottenere dati sull'tabah e spazi, così ho deciso di fare un sistema costituito da diversi componenti. Prima pre-elaborare tutte le 135 mila i file con le versioni e mettere i dati sul tabah e le lacune nella base di dati. Mi aspetto che sarà a lungo. E poi usare i dati di un database per ottenere rapidamente i dati in diversi formati.

Alla fine si è rivelato uno script fill_db . Questo script riempito i dati nella base di poco più di cinque ore. Ma questi cinque ore di questo quando già tutto era organizzato. Non la prima volta lo script ha lavorato. I principali problemi sono stati con Unicode. Prima c'è stato un problema con il rilascio di μ-0.01.tar.gz autore APEIRON, poi ci sono stati problemi con i file tipo t/words_with_ß.dat di rilascio Lingua-DE-ASCII-0.06 autore BIGJ. Ma alla fine tutti i problemi sono stati risolti e lo script può camminato per tutti .tar.gz release.

Lo script va per tutti .tar.gz file in CPAN. Decomprime .tar.gz in una cartella temporanea. Trova in questa cartella tutti i file che hanno estensione .pm, .pl, .t o .pod, legge tutto rientri e controlla se in questi rientri e spazi o tabulazioni. In release ci sono altri i file, ma ho deciso di limitarsi solo i file che si riferiscono esplicitamente al Perl.

Il risultato del lavoro di questo script è di 2 tabelle nel database. Ecco un esempio di dati:

mysql> select * from releases limit 1;
+------------+--------+---------------------------------------------------------------+------------+
| release_id | author | file_name                                                     | timestamp  |
+------------+--------+---------------------------------------------------------------+------------+
|          1 | RUFF   | /cpan/authors/id/R/RU/RUFF/DJabberd-Authen-Dovecot-0.1.tar.gz | 1359325895 |
+------------+--------+---------------------------------------------------------------+------------+
1 row in set (0.00 sec)

mysql> select * from files where release_id = 1;
+---------+------------+--------------------------------------------------------+------+---------------------+-------------------+
| file_id | release_id | file_name                                              | size | has_space_beginning | has_tab_beginning |
+---------+------------+--------------------------------------------------------+------+---------------------+-------------------+
|       1 |          1 | DJabberd-Authen-Dovecot/lib/DJabberd/Authen/Dovecot.pm | 2047 |                   1 |                 1 |
|       2 |          1 | DJabberd-Authen-Dovecot/t/compiles.t                   |   64 |                   0 |                 0 |
+---------+------------+--------------------------------------------------------+------+---------------------+-------------------+
2 rows in set (0.02 sec)

mysql> mysql> selec(*) from releases;
+----------+
| count(*) |
+----------+
|   135343 |
+----------+
1 row in set (0.04 sec)

mysql> select count(*) from files;
+----------+
| count(*) |
+----------+
|  3828079 |
+----------+
1 row in set (5.71 sec)

Solo gli spazi, solo taba taba e spazi, e...

Totale nel database su ogni file in stampa ci sono 2 bandiera:

  • se vengono utilizzati gli spazi in ritirata
  • se vengono utilizzate taba in ritirata

Rispettivamente da due bandiere può essere 4 combinazioni:

  • 11 — utilizzati e gli spazi e tabulazioni
  • 10 — vengono utilizzati solo gli spazi
  • 01 — vengono utilizzati solo taba
  • 00 — non vengono utilizzati né spazi, né di taba

Le prime tre opzioni è completamente attesi situazione, sono loro che mi voleva trovare e per saperne di che più popolare. Ma l'opzione 00 — "non vengono utilizzati né di taba, né spazi" — questo è quello che io assolutamente non ho pensato ma si è scoperto che così accade anche. "Come?" — si chiede. Ecco un esempio.

mysql> select releases.release_id, files.file_name, files.size, has_space_beginning, has_tab_beginning from releases join files on releases.release_id = files.release_id and author = 'KOHA';
+------------+---------------------------------------------------+------+---------------------+-------------------+
| release_id | file_name                                         | size | has_space_beginning | has_tab_beginning |
+------------+---------------------------------------------------+------+---------------------+-------------------+
|     118147 | Bundle-KohaSupport-0.31/lib/Bundle/KohaSupport.pm | 2169 |                   0 |                 0 |
|     118147 | Bundle-KohaSupport-0.31/t/Bundle-KohaSupport.t    |  487 |                   0 |                 0 |
|     118147 | Bundle-KohaSupport-0.31/t/pod.t                   |  130 |                   0 |                 0 |
+------------+---------------------------------------------------+------+---------------------+-------------------+
3 rows in set (0.05 sec)

L'autore KOHA c'è il rilascio Bundle-KohaSupport-0.31. In questa versione ci sono 3 file la cui estensione dalla lista .pm, .pl, .t o .pod. Su tutti questi file in un database scritto che nella loro ritirata né spazi, né tab. Come può essere?

Si scopre tutto elementare. Se se si guarda a questi file, allora semplicemente non rientro. Ecco, ad esempio, il contenuto di un file t/Bundle-KohaSupport.t:

# Before `make install' is performed this script should be runnable with
# `make test'. After `make install' it should work as `perl Bundle-KohaSupport.t'

#########################

# change 'tests => 1' to 'tests => last_test_to_print';

use Test::More tests => 1;
BEGIN { use_ok('Bundle::KohaSupport') };

#########################

# Insert your test code below, the Test::More module is use()ed here so read
# its man page ( perldoc Test::More ) for help writing this test script.

Quindi, oltre a tre attesi situazioni:

  • vengono utilizzati solo gli spazi
  • vengono utilizzati solo taba
  • utilizzati e gli spazi e tabulazioni

ancora è la situazione:

  • non vengono utilizzati gli spazi vuoti e non utilizzati taba

I dati per gli autori

Dopo che mi sono trattati i dati nel database ho deciso di vedere per ogni autore che si utilizza per il rientro.

Mi aspettavo che il più popolare sarà solo l'utilizzo di spazi, al secondo posto per popolarità sarà solo l'utilizzo di schede, mentre al terzo posto per popolarità sarà l'utilizzo simultaneo di schede e spazi.

Ma si è scoperto che ero completamente sbagliato.

Ho scritto uno script . Questo script controlla i simboli utilizzati dagli autori di tutti i file .pm, .pl, .t, .pod, che ci sono in tutte le loro uscite che ora ci sono su CPAN.

Ecco cosa è successo:

$ cat app/data/users.log | perl -nalE 'say if /^##/'
## 00 (nothing) - 50 (0.7%)
## 01 (only tabs) - 51 (0.7%)
## 10 (only spaces) - 1543 (21.9%)
## 11 (both) - 5410 (76.7%)

Dati assolutamente non come mi aspettavo!

  • Più del 75% degli autori utilizzano il mix di spazi e schede per il rientro.
  • Solo gli spazi al secondo posto, a poco più del 20%,
  • e gli autori che utilizzano solo di taba meno di un per cento.
  • Il numero di autori che non usano il rientro è quasi lo stesso come il numero di autori che utilizzano solo di taba.

L'elenco completo di tutti gli autori in una ripartizione pro gruppi ci sono file su GitHub .

Ma jupyter notebook  con il quale è stato costruito questo grafico a torta.

Ma si tratta di dati generati per tutti release, che ora ci sono su CPAN. Queste uscite sono stati creati nel corso degli ultimi 24 anni. Forse con il passare del tempo il rapporto qualcosa sta cambiando?

I dati su tempo

Ogni file con il rilascio su CPAN tempo di modifica è un tempo quando questo rilascio è stato caricato su CPAN. Questi dati caricati nel database. Ora su CPAN più vecchio di rilascio è Ioctl-0.5 — è stato caricato su CPAN 1995-08-20:

mysql> select author, file_name, from_unixtime(timestamp) from releases where timestamp = (select min(timestamp) from releases);
+--------+----------------------------------------------+--------------------------+
| author | file_name                                    | from_unixtime(timestamp) |
+--------+----------------------------------------------+--------------------------+
| KJALB  | /cpan/authors/id/K/KJ/KJALB/Ioctl-0.5.tar.gz | 1995-08-20 07:26:09      |
+--------+----------------------------------------------+--------------------------+
1 row in set (0.08 sec)

E in questo giorno era macchiato di una volta 8 uscite:

mysql> select * from releases where from_unixtime(timestamp) < '1995-08-21' order by timestamp;
+------------+--------+--------------------------------------------------------------+-----------+
| release_id | author | file_name                                                    | timestamp |
+------------+--------+--------------------------------------------------------------+-----------+
|     112505 | KJALB  | /cpan/authors/id/K/KJ/KJALB/Ioctl-0.5.tar.gz                 | 808903569 |
|      23026 | TYEMQ  | /cpan/authors/id/T/TY/TYEMQ/FileKGlob.tar.gz                 | 808903636 |
|     134031 | WPS    | /cpan/authors/id/W/WP/WPS/Curses-a8.tar.gz                   | 808903647 |
|     112546 | KJALB  | /cpan/authors/id/K/KJ/KJALB/Term-Info-1.0.tar.gz             | 808903748 |
|      70278 | MICB   | /cpan/authors/id/M/MI/MICB/TclTk-b1.tar.gz                   | 808910379 |
|      70274 | MICB   | /cpan/authors/id/M/MI/MICB/Tcl-b1.tar.gz                     | 808910514 |
|      19408 | GBOSS  | /cpan/authors/id/G/GB/GBOSS/perl_archie.1.5.tar.gz           | 808930091 |
|      81551 | JKAST  | /cpan/authors/id/J/JK/JKAST/StatisticsDescriptive-1.1.tar.gz | 808950837 |
+------------+--------+--------------------------------------------------------------+-----------+
8 rows in set (0.06 sec)

Ho deciso di vedere come cambia la distribuzione l'uso di diversi caratteri per i rientri di tempo. Per questo ho scritto uno script .

Ecco un frammento di file di dati, che ha creato lo script:

$ cat app/data/releases_date.csv | head
date,00,01,10,11
1995-08-20,0,1,0,7
1995-08-21,0,0,0,0
1995-08-22,0,0,0,0
1995-08-23,0,0,0,0
1995-08-24,0,0,0,1
1995-08-25,0,0,0,0
1995-08-26,0,0,0,0
1995-08-27,0,0,0,0
1995-08-28,0,0,0,0

Cioè su ogni data di partenza con 1995-08-20 ci sono i dati su quanto è stato uscite suddivise per quello quali sono i caratteri utilizzati per il rientro.

  • 00 — in ritirata né spazi, né schede
  • 01 — in ritirata vengono utilizzati solo taba
  • 10 — in ritirata vengono utilizzati solo gli spazi
  • 11 — in отсутпах utilizzati e taba e spazi

Sopra ho scritto jupyter notebook  in cui ha disegnato il grafico. Sul grafico ho отображаю non il numero assoluto di uscite con una ripartizione per tipo di rientro, e la percentuale del numero totale di uscite in questo giorno:

Sul grafico appare quasi 9 mila giorni. Visto che c'è una tendenza, ma il grafico vivace e sul male, si vede tutto. Perché invece di giorni sono diventato группировал uscite mese per mese.:

Incredibile ma tracciata tendenza. Il numero di uscite in cui vengono utilizzati solo taba o, in generale, non vengono utilizzati rientro praticamente non cambia, ma la quota di uscite in cui vengono utilizzati solo gli spazi costantemente in crescita e questa crescita è dovuta la quota di uscite in cui vengono utilizzati miscela di schede e spazi.

Perché cresce "solo spazi vuoti". Ipotesi numero 1

Ho guardato i dati e ho avuto una ipotesi perché diminuisce il numero di uscite in cui viene utilizzato e i problemi e taba. Il mio pensiero pro Perl libreria Module::Install . Se durante la scrittura di sua libreria viene utilizzata Module::Install, in stampa su CPAN sono inclusi i file da questa libreria. E in questi file utilizza una miscela di spazi e tab. Ecco un esempio di file da Module::Install in un comunicato Devel-PeekPoke-0.04:

mysql> select * from files where release_id = 284 and file_name like '%inc/Module/Install%';
+---------+------------+----------------------------------------------------+-------+---------------------+-------------------+
| file_id | release_id | file_name                                          | size  | has_space_beginning | has_tab_beginning |
+---------+------------+----------------------------------------------------+-------+---------------------+-------------------+
|   10328 |        284 | Devel-PeekPoke-0.04/inc/Module/Install.pm          | 12381 |                   1 |                 1 |
|   10329 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/Metadata.pm | 18111 |                   1 |                 1 |
|   10330 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/Fetch.pm    |  2455 |                   1 |                 1 |
|   10331 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/Makefile.pm | 12063 |                   1 |                 1 |
|   10332 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/Base.pm     |  1127 |                   0 |                 1 |
|   10333 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/WriteAll.pm |  1278 |                   0 |                 1 |
|   10334 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/Win32.pm    |  1795 |                   1 |                 1 |
|   10335 |        284 | Devel-PeekPoke-0.04/inc/Module/Install/Can.pm      |  3183 |                   1 |                 1 |
+---------+------------+----------------------------------------------------+-------+---------------------+-------------------+
8 rows in set (0.03 sec)

La mia ipotesi è che gli sviluppatori utilizzano gli spazi per il rientro, ma a causa del fatto che in un comunicato si trova Module::Install poi nelle statistiche contano e gli spazi e le tabulazioni. Module::Install diventati meno utilizzare (così come è apparso tutti i tipi di Dist::Zilla, Dist::Milla, Minilla) e quindi Module::Install ha smesso di dare la distorsione.

Questa ipotesi da verificare. Innanzitutto ho deciso di vedere se davvero Module::Install vengono utilizzati sempre meno e meno. Ho costruito un grafico. Ogni punto è il numero di uscite per il mese in cui è stato utilizzato Module::Install. Visto che una parte di ipotesi verne — davvero, Module::Install utilizzare acciaio meno.

Ma se uso Module::Install influisce sulla percentuale di utilizzo di spazi o tab e spazi per di rientro. Per scoprirlo, ho disegnato due grafica. Questo è il numero di diversi tipi di rientro in uscite per mese. Il primo grafico solo i comunicati in cui viene utilizzato Module::Install, il secondo grafico solo uscite in cui non viene utilizzato.

Qui si vede che davvero, se si utilizza la libreria Module::Install, più spesso in biblioteca usato si tratta di una miscela schede e spazi.

E questo è un grafico in cui vengono visualizzate solo quelle uscite in cui non viene utilizzato Module::Install. Se confrontiamo questo il calendario con il programma a cui si rivolgono tutti i comunicati, la differenza c'è, ma niente non è cambiata.

Si scopre che l'ipotesi non è corretta. Se la stampa viene utilizzato Module::Install, il rilascio più spesso entra nel gruppo "tabulazioni e spazi", ma se non tenere conto di tutte le versioni in cui viene utilizzato Module::Install, è ancora una tendenza — la quota di uscite in cui vengono utilizzati solo taba come rientro in crescita a scapito della quota di uscite in cui vengono utilizzati miscela di schede e spazi.

Perché cresce "solo spazi vuoti". Ipotesi numero 2

Perché sono in continuo aumento il numero di uscite in cui vengono utilizzati solo taba? Può essere un po ' di più attivo l'autore, che rilasciano un sacco di uscite e questi, l'autore influenzano tutte le statistiche?

Ho provato a controllare. Ha disegnato il grafico che mostra la percentuale di uscite in cui sono stati utilizzati solo gli spazi, ma suddivisi per lettera iniziale del nome dell'autore. Se davvero qualche l'autore portò sopra un grande contributo al comune statistiche, una linea molto bruscamente andando verso l'alto. In quel grafico che ho visto, tutte le linee più o meno regolari. Quindi conferma di questa ipotesi, non ho stato in grado di ottenere.

Perché cresce "solo spazi vuoti". Ipotesi numero 3

Dai grafici si vede che con il passare del tempo diventa sempre più uscite in cui vengono utilizzati solo spazi per il rientro. E questa percentuale è in aumento a causa di uscite in cui viene utilizzata una miscela di spazi e tab.

La mia prima ipotesi era che così succede che in stampa prima attivamente incluso il codice della libreria Module::Install in cui è stata utilizzata una miscela di spazi e tab, questa libreria usano sempre di meno, e quindi la quota di uscite in cui viene utilizzata una miscela di schede e spazi ridotti. Si è scoperto che una parte di verità in questo, ma anche se rimuovi esame di tutte le versioni in cui viene utilizzato Module::Install, la tendenza generale non cambia — comunque la quota di uscite in cui solo gli spazi cresce a scapito della quota di uscite in cui utilizza una miscela di spazi e tab.

La mia seconda ipotesi che influenzano le statistiche molto piccolo set molto attivi gli autori. Non sono riuscito a trovare conferma di questa ipotesi.

La mia terza ipotesi è che gli autori appaiono più comodo editor di testo e IDE, grazie al quale diventa più facile usare tranquillamente solo spazi vuoti, e non una miscela di spazi e tab. Ma, purtroppo, le idee come verificare questa ipotesi non ho. I dati che si trovano su CPAN non ci sono informazioni sul fatto che l'editor è stato usato per creare questa release. Ho guardato la data release popolare editor/IDE:

  • Emacs — 1985
  • vim — 1991
  • IntelliJ IDEA — январяь 2001
  • Eclipse — novembre 2001
  • Sublime Text — gennaio 2008
  • Atom — febbraio 2014
  • VS Code — aprile 2015

I dati per gli autori per il 2019

Al precedente streaming per il titolo visto che con il passare del tempo diventa sempre più uscite in cui vengono utilizzati gli spazi, e non una miscela di schede con spazi. Così ho deciso di vedere la distribuzione di quali tipi di rientro viene utilizzato dagli autori solo sulla base delle loro uscite per il 2019.

I dati dei risultati del lavoro di script :

$ cat app/data/users_2019.log | perl -nalE 'say if /^##/'
## 00 (nothing) - 12 (1.4%)
## 01 (only tabs) - 9 (1.0%)
## 10 (only spaces) - 355 (41.2%)
## 11 (both) - 486 (56.4%)

Se confrontiamo i dati per gli autori per il 2019 e i dati per tutto l'anno, visto che la percentuale di autori che usa solo taba praticamente non cambia, ma la quota di gli autori che utilizzano solo spazi notevolmente aumentato.

Il codice sorgente per questo grafico a torta:

I fattori che influenzano la correttezza di dati

Per la formazione di numeri e grafici sono stati usati tutti .tar.gz uscite, che sono stati su CPAN al momento dell'inizio della stesura di questo articolo, oltre a uscite più il linguaggio di programmazione Perl.

CPAN consente di eliminare le uscite, i dati che sono indicati in questo articolo eliminati i comunicati non hanno partecipato. Non è chiaro quanto si scambieranno i dati se prendere in considerazione i caratteri di spaziatura già eliminati uscite. E ' possibile che i dati cambiano di molto. Esiste un archivio backpan  che memorizza tutti i comunicati, che quando sono su CPAN. Quindi in teoria c'è la possibilità di ricalcolare tutti i numeri in base uscite che già non su CPAN.

Il secondo momento, che influisce sulla precisione dei dati è quello che sono stati presi in considerazione i caratteri rientro solo in uscite, che sono stati confezionati .tar.gz archivio. Altri tipi di gli archivi non sono stati utilizzati. La stragrande maggioranza delle uscite è .tar.gz quindi è stato fatto questo presupposto. Se contate i dati di tutti gli archivi dati sicuramente cambieranno. Immagino che la modifica non sarà più breve per cento.

Il codice sorgente

L'intero set di script, che sono stati utilizzati per la raccolta dei dati, i dati stessi e jupyter computer portatili tutto è disponibile nel repository su GitHub.

Il codice che è scritto è proprio molto lontano dalla perfezione. Tutto ciò che è stato scritto scritto con idee più velocemente possibile per ottenere il risultato, e non creare un codice perfetto.

Curriculum

Al momento della stesura di questo testo nel repository di librerie Perl CPAN era di circa 135 mila comunicati. Il primo rilascio è stato fatto 24 anni fa (1995-08-20). In queste uscite è di quasi 4 milioni di file con estensione .pm, .pl, .t o .pod.

Se consideriamo i dati per tutto il tempo, si ottiene che il 76.7%% autori in ritirata utilizzano il mix di spazi e tab, 21.9% usano in ritirata solo spazi vuoti, e 0.7% — solo di taba.

Ma se si considerano solo i dati per il 2019, che sta diventando sempre di più gli autori che utilizza solo spazi per rientro, ma comunque la maggior parte utilizza una miscela di schede e spazi (56.4% — usano e taba e spazi,spazi 41.2% — solo spazi vuoti, 1.0% — solo di taba).

E se guardare il grafico di modifiche della quota di utilizzo di diversi tipi di rientro, visto che la quota di utilizzare solo gli spazi in crescita e questa percentuale cresce la quota di chi utilizza una miscela di schede e di spazi per il rientro.

Non è noto con precisione, perché questa percentuale è in aumento. È possibile che questo accade a causa del fatto che gli autori usano più comodo editor di testo, che consentono un più facile e più sicuro installare quali sono i caratteri da utilizzare per il rientro.

Altri articoli