Perché gli amministratori di sistema dovrebbero concedere in licenza il proprio codice per l'open source
Uno dei modi migliori che conosco per restituire qualcosa alla comunità open source che fornisce a tutti programmi incredibili è rendere programmi e script open source utilizzando una licenza appropriata.
Come amministratore di sistema Linux, scrivo una discreta quantità di codice.
Ti sorprende? Bene, mi sforzo di essere l'amministratore di sistema "pigro" e lo faccio, in parte, riducendo il numero di attività ripetitive che devo svolgere automatizzandole. La maggior parte della mia automazione è iniziata come piccoli programmi da riga di comando. Li memorizzo in script eseguibili per riutilizzarli in qualsiasi momento su qualsiasi host Linux di cui sono responsabile.
Il problema con la condivisione di codice senza licenza
Mi piace anche condividere il mio codice. Penso che, se il mio codice mi ha aiutato a risolvere un problema, può anche aiutare altri amministratori di sistema a risolvere problemi uguali o simili. Dopotutto, questa è l'essenza dell'open source: la condivisione del codice. Sebbene la condivisione del codice sia una buona cosa, i problemi legali possono impedire che un codice perfettamente valido venga utilizzato come previsto dallo sviluppatore.
Il problema principale è che molte aziende dispongono di uffici legali che richiedono loro di conservare copie delle licenze. Ciò facilita la comprensione dei loro diritti e obblighi. Il software senza licenza ad esso allegata diventa in alcun modo una responsabilità legale. Questo perché non esiste alcuna base su cui determinare se il codice possa essere utilizzato legalmente o meno. Ciò può impedire l'utilizzo di codice perfettamente valido da parte di molte aziende e individui.
Perché concedo in licenza il mio codice
Uno dei modi migliori che conosco per restituire qualcosa alla comunità open source che fornisce a tutti programmi incredibili come le GNU Utilities, il kernel Linux, LibreOffice, WordPress e migliaia di altri, è rendere programmi e script open source utilizzando una licenza appropriata .
Solo perché scrivi un programma, credi nell'open source e sei d'accordo sul fatto che i programmi dovrebbero essere codice open source, non significa che sia open source. Come amministratore di sistema, scrivo molto codice, ma quanti di voi prendono mai in considerazione la possibilità di concedere in licenza il proprio codice?
Devi scegliere di dichiarare esplicitamente che il tuo codice è open source e decidere con quale licenza desideri che venga distribuito. Senza questo passaggio critico, il codice creato sarà funzionalmente proprietario. Ciò significa che la comunità non può trarre vantaggio in modo sicuro dal tuo lavoro.
Dovresti includere l'intestazione della licenza GPLv2 (o altra tua preferenza) come opzione della riga di comando che stampa l'intestazione della licenza sul terminale. Quando distribuisci il codice, ti consiglio anche di includere una copia testuale dell'intera licenza insieme al codice (è un requisito per alcune licenze).
Qualche anno fa ho letto un articolo interessante, Il codice sorgente è la licenza che aiuta a spiegare il ragionamento alla base di questo.
Trovo molto interessante che in tutti i libri che ho letto e in tutti i corsi a cui ho partecipato, nessuno mi abbia detto nemmeno una volta di includere una licenza per il codice che ho scritto nei miei compiti di amministratore di sistema. Tutte queste fonti ignoravano completamente il fatto che anche gli amministratori di sistema scrivono codice. Anche nelle sessioni della conferenza sulle licenze a cui ho partecipato, l'attenzione era concentrata sul codice dell'applicazione, sul codice del kernel e persino sulle utilità di tipo GNU. Nessuna delle presentazioni ha nemmeno accennato al fatto che dovresti prendere in considerazione la possibilità di concedergli una licenza in alcun modo.
Forse hai avuto un'esperienza diversa, ma questa è stata la mia. Per lo meno, questo mi frustra, al massimo mi fa arrabbiare. Svaluti il tuo codice quando trascuri di concedergli la licenza. Molti amministratori di sistema non pensano nemmeno alla licenza, ma è importante se vuoi che il tuo codice sia disponibile per l'intera comunità. Non si tratta né di credito né di denaro. Si tratta di garantire che il tuo codice sia, ora e sempre, disponibile agli altri nel senso migliore di "gratuito e open source".
Eric Raymond, autore del libro del 2003, The Art of Unix Programming, scrive che agli albori della programmazione dei computer e soprattutto agli albori di Unix, la condivisione del codice era uno stile di vita. All'inizio si trattava semplicemente di riutilizzare il codice esistente. Con l'avvento di Linux e delle licenze open source, tutto ciò è diventato molto più semplice. Soddisfa le esigenze degli amministratori di sistema di poter condividere e riutilizzare legalmente il codice open source.
Raymond afferma: "Gli sviluppatori di software vogliono che il loro codice sia trasparente. Inoltre non vogliono perdere i loro toolkit e la loro esperienza quando cambiano lavoro. Si stancano di essere vittime, stufi di essere frustrati da strumenti bruschi e diritti di proprietà intellettuale". recinzioni e dover reinventare ripetutamente la ruota ” Questa affermazione si applica anche agli amministratori di sistema, che sono, di fatto, anche sviluppatori di software.
Come concedo in licenza il mio codice
Ho menzionato l'aggiunta di un'opzione per stampare l'intestazione della licenza GPL (o altra) come opzione della riga di comando. Il codice seguente è una procedura che fa ciò:
#############################################
# Print the GPL license header #
#############################################
gpl()
{
echo
echo "############################################################"
echo "# Copyright (C) 2023 David Both #"
echo "# http://www.both.org #"
echo "# #"
echo "# This program is free software; you can redistribute it #"
echo "# and/or modify it under the terms of the #"
echo "# GNU General Public License as published by the #"
echo "# Free Software Foundation; either version 2 of the #"
echo "# License, or (at your option) any later version. #"
echo "# #"
echo "# This program is distributed in the hope that it will be #"
echo "# useful, but WITHOUT ANY WARRANTY; without even the #"
echo "# implied warranty of MERCHANTABILITY or FITNESS FOR A #"
echo "# PARTICULAR PURPOSE. See the GNU General Public License #"
echo "# for more details. #"
echo "# #"
echo "# You should have received a copy of the GNU General #"
echo "# Public License along with this program; if not, write #"
echo "# to the Free Software Foundation, Inc., 59 Temple Place, #"
echo "# Ste 330, Boston, MA 02111-1307 USA #"
echo "############################################################"
echo
} # End of gpl()
end
Questa è la licenza, inclusa come funzione. Puoi aggiungere un'opzione al codice. Mi piace posizionare le nuove sezioni del caso in ordine alfabetico per renderle un po' più facili da trovare durante l'esecuzione della manutenzione. Questa è la GPL
, quindi ho scelto g
come opzione breve:
#########################################
# Process the input options #
#########################################
# Get the options
while getopts ":ghc" option; do
case $option in
c) # Check option
Check=1;;
g) # display the GPL header
gpl
exit;;
h) # Help function
Help
exit;;
\?) # incorrect option
echo "Error: Invalid option."
exit;;
esac
done
end
Questi due bit di codice sono tutto ciò che serve per aggiungere una licenza legittima e applicabile al tuo programma.
Pensieri finali
Concedo sempre la licenza per tutto il mio codice. Recentemente ho presentato una sessione su Bash all'OLF (Open Libre Free, un tempo conosciuto come Ohio Linux Fest). Invece di utilizzare LibreOffice Impress per la mia presentazione, ho utilizzato un programma Bash per l'intera presentazione. Dopo tutto, è una presentazione su Bash, quindi perché non renderlo un programma Bash.
Ho incluso il mio codice di licenza in quel programma Bash. In questo modo tutti coloro che incontrano una copia del mio programma sanno che ha la licenza GPLv3 e che possono usarlo e modificarlo secondo i termini di quella licenza. Il mio codice è la licenza.